# Kaëlig Barillet
# Jonathan Begot
# Laurence Berville
# Les packages :
import pandas as pd
import numpy as np
import squarify # pip install squarify (algorithm for treemap)
import matplotlib.pyplot as plt
import seaborn as sb # couleurs
import colorcet as cc # pour avoir bcp de couleur
import mysql.connector#pip install mysql-connector-python
import matplotlib.patches as mpatches
pd.options.mode.chained_assignment = None # default='warn'
# Les Tables :
popu = pd.read_csv("FAOSTAT_2013_population.csv",
dtype={'Valeur':np.float32},
converters={"Code zone (M49)": str,"Note": str,"Code année": str,"Année": str, "Code Élément": str, "Code Produit": str},
decimal='.')
Les fichiers de la population mondiale pour l’année 2013 contiennent 15 variables :
Le code domaine et sa traduction Domaine : ici, nous sommes dans les bilans Alimentaires.
Le code Zone M49 et la zone,
Le code Element et sa traduction Element,les deux colonnes contiennent des valeurs uniques,
Le code produit et le produit étudié, les deux colonnes contiennent des valeurs uniques,
Le code année et l'année. Ici 2013. Les deux colonnes contiennent des valeurs uniques,
Les unités,
La valeur,
Le symbole et sa traduction avec la colonne Description du symbole.
Et une colonne note.
dispoA = pd.read_csv("FAOSTAT_2013_animal.csv",
dtype={'Valeur':np.float64},
converters={"Code Pays": str,"Code Année": str, "Année": str,"Code Élément": str, "Code Produit": str},
decimal='.')
dispoC= pd.read_csv("FAOSTAT_2013_cereal.csv",
dtype={'Valeur':np.float64},
converters={"Code Pays": str,"Code Année": str, "Année": str,"Code Élément": str, "Code Produit": str },
decimal='.')
dispoV= pd.read_csv("FAOSTAT_2013_vegetal.csv",
dtype={'Valeur':np.float64},
converters={"Code Pays": str,
"Code Année": str,
"Année": str,
"Code Élément": str,
"Code Produit": str },
decimal='.')
Les fichiers de disponibilité alimentaire (vegetal, animal et cereal) pour l’année 2013 contiennent 14 variables :
Le code domaine et sa traduction Domaine : ici, nous sommes dans les bilans Alimentaires.
Le code pays et le pays,
Le code Element et sa traduction Element,
Le code produit et le produit étudié,
Le code année et l'année. Ici 2013.
Les unités,
La valeur,
Le symbole et sa traduction avec la colonne Description du symbole.
Les 3 tables ont les mêmes entêtes, dans le même ordre. La table Céreale et totalement inclus dans la table Végétaux.
# Observations des datas - Les différents pays étudiés :
ListePays_A=set(dispoA["Pays"].values.tolist())
print("Nombre de pays dans la data DispoAnimal est de",len(ListePays_A))
ListePays_V=set(dispoV["Pays"].values.tolist())
print("Nombre de pays dans la data DispoVégétal est de",len(ListePays_V))
ListePays_C=set(dispoC["Pays"].values.tolist())
print("Nombre de pays dans la data DispoCéréal est de",len(ListePays_C))
# Vérification que les pays dans les 3 tables disponibilités alimentaires sont identiques
if set(ListePays_A) == set(ListePays_V) == set(ListePays_C):
print("Les pays sont identiques dans les 3 dataframes : Cereal / Animal et Vegetal")
else:
print("Les listes sont différentes")
Nombre de pays dans la data DispoAnimal est de 175 Nombre de pays dans la data DispoVégétal est de 175 Nombre de pays dans la data DispoCéréal est de 175 Les pays sont identiques dans les 3 dataframes : Cereal / Animal et Vegetal
# Statistiques descriptives :
summary_across_rows = pd.DataFrame(popu).describe()
print(summary_across_rows )
fig = plt.figure(figsize =(10, 3))# taille du graphique
bp=plt.boxplot(popu['Valeur'],
patch_artist = True,
notch ='True', vert = 0) # boite à moustache
plt.title("Distribution de la population mondiale en milliers d'habitants")# Titre
for cap in bp['caps']: # pour personnaliser les caps
cap.set(color ='#8B008B',
linewidth = 2)
for median in bp['medians']: # changer les couleurs de la médiane
median.set(color ='red',
linewidth = 3) # et l'épaisseur
plt.show()# afficher le graphique
Valeur count 2.350000e+02 mean 3.683382e+04 std 1.561302e+05 min 5.740000e-01 25% 4.015375e+02 50% 5.414739e+03 75% 2.059915e+04 max 1.407321e+06
On note la présence de 3 "outliers".
# Data alimentaires :
summary_across_rowsA = pd.DataFrame(dispoA).describe()
print(summary_across_rowsA )
summary_across_rowsC = pd.DataFrame(dispoC).describe()
print(summary_across_rowsC)
summary_across_rowsV = pd.DataFrame(dispoV).describe()
print(summary_across_rowsV)
Valeur
count 37166.000000
mean 148.291647
std 1933.728473
min -1368.000000
25% 0.000000
50% 1.000000
75% 11.000000
max 135600.000000
Valeur
count 16057.000000
mean 608.890108
std 6947.381722
min -39863.000000
25% 0.000000
50% 3.000000
75% 54.620000
max 353699.000000
Valeur
count 104871.000000
mean 321.271016
std 6395.039684
min -39863.000000
25% 0.000000
50% 1.000000
75% 17.000000
max 739267.000000
On note la présence de chiffres négatifs.
# Graphiques :
data=[dispoV['Valeur'], dispoA['Valeur']] # liste des données analysées
fig=plt.figure(figsize =(25, 10)) # taille du graphique
ax=fig.add_subplot(313) # taille de chaque élement du graphique
colors=['#00FF00','#FFFF00'] # couleurs
bp1 = ax.boxplot(data, # nos datas
patch_artist = True,# pour modifier les éléments de la boite à moustache
notch ='True',
vert = 0) # horizontal pour gagner de la place
# boucle pour changer les couleurs des boites et des écarts
for patch, color in zip(bp1['boxes'], colors):
patch.set_facecolor(color)
for whisker in bp1['whiskers']:
whisker.set(color ='#8B008B', # couleur de la ligne
linewidth = 1.5,# taille de la ligne
linestyle =":")# ligne en .....
for cap in bp1['caps']:
cap.set(color ='#8B008B', #couleur
linewidth = 2)# taille du caps
for median in bp1['medians']:
median.set(color ='red', # couleur mediane
linewidth = 2) # taille
for flier in bp1['fliers']:
flier.set(marker ='o', # forme des points
color ='#8B008B',
alpha = 0.8) # transparence
# x-axis labels
ax.set_yticklabels(['Vegetal', 'Animal'])
# Adding title
plt.title("Disponibilité alimentaire mondiale, en Milliers de tonnes d'après la FAO, en 2013.")
# Removing top axes and right axes ticks
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
# show plot
plt.show()
# Question 1 : Population mondiale et duplicata de la chine
Total = popu["Valeur"].sum()
print(f'La population mondiale annoncée en 2013 était de {int(Total*1000):,},habitants. Nous notons une erreur \ncar la population mondiale est passée au dessus de 8 milliards en 2022.'.replace(',', ' '))
# Erreur avec la Chine
Chine = popu.query("Zone=='Chine'")["Valeur"] #print(type(Chine))
Chine = list(Chine)[0]
print(f'On enlève donc la chine qui est incluse deux fois dans les datas = {int(Chine*1000,):,}, habitants'.replace(',', ' '))
print(f'La population mondial en 2013 était de {int((Total - Chine)*1000):,},habitants.'.replace(',', ' '))
La population mondiale annoncée en 2013 était de 8 655 949 000 habitants. Nous notons une erreur car la population mondiale est passée au dessus de 8 milliards en 2022. On enlève donc la chine qui est incluse deux fois dans les datas = 1 407 320 875 habitants La population mondial en 2013 était de 7 248 628 125 habitants.
Redondance :
Comme nous l'avons observé lors de l'ouverture des tables, il y a des colonnes qui donnent la même information. Nous allons donc simplifier le tableau :
Voici un exemple avec le Blé et la France :
# création de sous tableau
FranceV=dispoV[dispoV['Pays']=='France']# Sous tableau avec que la France
FranceBle=FranceV[FranceV['Produit']=='Blé']# Sous tableau avec que le blé de France
# J'enlève les colonnes non utiles :
FranceBle= FranceBle.drop(columns=["Code Domaine", "Description du Symbole","Domaine",
"Code Pays", "Pays","Année", "Code Produit", "Produit", "Code Année"])
# Puis on remarque des redondances dans les valeurs :
FrBle=FranceBle[FranceBle['Symbole']=='S']# Sous tableau avec que les données en tonnes
# J'ajoute une colonne avec la valeur en kg
FrBle['ValeurKg'] = FrBle['Valeur'] * 1000
# J'enlève Unité
FrBle= FrBle.drop(columns=["Unité"])
# La Disponibilite interieure est égale à (Importation - Exportation) + Production + Variation de stock
ImportationFR_Ble = list(FrBle.query("Élément=='Importations - Quantité'")["ValeurKg"])[0]
ExportationFR_Ble = list(FrBle.query("Élément=='Exportations - Quantité'")["ValeurKg"])[0]
ProductionFR_Ble = list(FrBle.query("Élément=='Production'")["ValeurKg"])[0]
DispoInt_FR_Ble = list(FrBle.query("Élément=='Disponibilité intérieure'")["ValeurKg"])[0]
Variation_FR_Ble = list(FrBle.query("Élément=='Variation de stock'")["ValeurKg"])[0]
print('ImportationFR_Ble', '-', 'ExportationFR_Ble','+','ProductionFR_Ble','+ Variation de stock','= Disponibilité intérieure' )
print('(',ImportationFR_Ble,'-', ExportationFR_Ble,') +',ProductionFR_Ble,'+', Variation_FR_Ble,'=', (ImportationFR_Ble-ExportationFR_Ble)+ProductionFR_Ble + Variation_FR_Ble )
print( 'La disponibilité intérieur en Blé =' , DispoInt_FR_Ble)
ImportationFR_Ble - ExportationFR_Ble + ProductionFR_Ble + Variation de stock = Disponibilité intérieure ( 2055000.0 - 21502000.0 ) + 38614000.0 + 1131000.0 = 20298000.0 La disponibilité intérieur en Blé = 20298000.0
#La Disponibilite interieure est utilisée en Nourriture + Perte + Semences + Traitement + Alimentation Animale + Autres Utilisations
NourritureFR_Ble = list(FrBle.query("Élément=='Nourriture'")["ValeurKg"])[0]
PerteFR_Ble = list(FrBle.query("Élément=='Pertes'")["ValeurKg"])[0]
SemencesFR_Ble = list(FrBle.query("Élément=='Semences'")["ValeurKg"])[0]
Traitement_FR_Ble = list(FrBle.query("Élément=='Traitement'")["ValeurKg"])[0]
AlimentationA_FR_Ble = list(FrBle.query("Élément=='Aliments pour animaux'")["ValeurKg"])[0]
AutreU_FR_Ble = list(FrBle.query("Élément=='Autres Utilisations'")["ValeurKg"])[0]
print("La Disponibilite interieure est utilisée en Nourriture + Perte + Semences + Traitement + Alimentation Animale \n + Autres Utilisations =",
NourritureFR_Ble+PerteFR_Ble+SemencesFR_Ble+Traitement_FR_Ble+AlimentationA_FR_Ble+AutreU_FR_Ble )
La Disponibilite interieure est utilisée en Nourriture + Perte + Semences + Traitement + Alimentation Animale + Autres Utilisations = 20298000.0
# Graphique en barre Horiz, sur utilisation du blé en France en 2013
# Data :
objects =('Perte','Semences','Traitement','Autre','Nourriture','Ali. animal')
y_pos = np.arange(len(objects))# taille de l'axe y
performance=[PerteFR_Ble,SemencesFR_Ble,Traitement_FR_Ble,AutreU_FR_Ble,NourritureFR_Ble,AlimentationA_FR_Ble]
color = ['rosybrown','tomato', 'orange', 'lime','royalblue', 'peru']
#Graph:
plt.figure(figsize =(10,7)) # taille de la "feuille" (larg, hauteur)
plt.barh(y_pos, performance,
align='center',
color=color,
alpha=0.9)
plt.yticks(y_pos, objects)# legende y (longueur et noms)
plt.xlabel('Usage (Kg)')# legence x
plt.title("Utilisation intérieure du blé en France, en 2013, d'après la FAO")# titre
plt.savefig("Utilisation intérieure du Blé_France_2013 en kg.png", dpi=500)
plt.show()
# Graph : Disponibilite interieur en Blé en France en 2013 :
# Data :
Variables =('Disponibilité \n intérieure','Importations','Exportations','Production','Variation \n de stock')
DisopBle=[DispoInt_FR_Ble,ImportationFR_Ble,ExportationFR_Ble,ProductionFR_Ble,Variation_FR_Ble]
# Représentation en Treemaps avec les fonctions inclues dans squarify :
squarify.plot(sizes=DisopBle,
label=Variables,
color = sb.color_palette("Set1",
len(DisopBle)),
pad = 0.001,# blanc pour séparer les carrés
#ec = 'black', #E ligne noir autour des carrés
text_kwargs = {'fontsize': 7, 'color': 'black'}, # taille de la legende et couleur
alpha=.9)# transparance des couleurs
plt.axis('off')
plt.title('Disponibilité intérieure en blé, en France en 2013')# rajouter un titre
plt.savefig("Squarify Disponibilité interieur du Blé_France_2013.png", dpi=500)
plt.show()
Chaque case de couleur représente un pays et sa taille est proportionnelle à la part de la population totale du monde.
# # Graphique en lolipops horizontal avec l ensemble des données sur le ble francais:
plt.figure(figsize =(15, 8)) # taille de la "feuille" (larg, hauteur)
ordered_df = FrBle.sort_values(by='Valeur') # trier les données en ordre decroissant
my_range=range(1,len(FrBle.index)+1)
# Horizontal version
plt.hlines(y=my_range, xmin=0, xmax=ordered_df['Valeur'], color='skyblue')
plt.plot(ordered_df['Valeur'], my_range, "D")
plt.yticks(my_range, ordered_df['Élément'])
plt.title('Utilisation intérieure du blé, en France en 2013, en milliers de tonnes')# rajouter un titre
#plt.savefig("Utilisation intérieure du Ble_France_2013.png", dpi=500)
plt.show()
#Question 3a : Population:
# enlever les cols inutiles.
PopulationM= popu.drop(columns=["Code Domaine","Code zone (M49)","Domaine","Note", "Code Élément","Élément","Description du Symbole","Symbole", "Produit","Code Produit", "Année", "Code année"])
PopulationM ['habitant'] = PopulationM['Valeur'] * 1000
PopulationM= PopulationM.drop(columns=["Valeur","Unité"])# Sous tableau avec que les habitants
PopulationM=PopulationM.rename(columns={'Zone':'Pays'})
PopulationM.set_index("Pays", inplace=True)
PopulationM = PopulationM.drop('Chine') # On enlève la Chine
PopulationM['pays'] = PopulationM.index
ordered_PopulationM= PopulationM.loc[:, ["habitant","pays"]].sort_values(by="habitant",
ascending=False)[:56]
# plot :
palette = sb.color_palette(cc.glasbey, n_colors=56)
plt.figure(figsize =(17, 12)) # taille de la "feuille" (larg, hauteur)
squarify.plot(sizes=ordered_PopulationM['habitant'],
label=round((ordered_PopulationM["habitant"]/1000000),1),
color=palette,
#pad = 0.001,# blanc pour séparer les carrés
ec = 'white', #ligne autour des carrés
text_kwargs = {'fontsize': 10,
'color': 'black',
'alpha' :0.8 }, # taille de la legende et couleur
alpha=.7)# transparance des couleurs
plt.legend(labels=ordered_PopulationM['pays'],
loc="upper center",
fontsize="8",
ncol=7,
fancybox=True, shadow=True,
bbox_to_anchor=(0.5, -0.01))
plt.title(
label='Population mondiale, en millions, en 2013 donnée FAO (Top 56 pays)',
fontdict={"fontsize":16},
pad=20)
plt.axis('off')
plt.savefig("Population mondiale en millions.png", dpi=600)
plt.show()
# Question 3b : Population Mettre les deux tables disponibilités ensemble.
dispoV= dispoV.drop(columns=["Code Domaine","Domaine", "Description du Symbole", "Symbole","Domaine", "Code Pays", "Année", "Code Année"])
dispoA= dispoA.drop(columns=["Code Domaine","Domaine", "Description du Symbole", "Symbole","Domaine", "Code Pays", "Année", "Code Année"])
dispoV.set_index("Pays", inplace=True) # Passage de Pays en index
dispoV = dispoV.drop('Chine') # On enlève la Chine
dispoV =dispoV[(dispoV.Valeur > 0)]# Que les valeures positives
dispoA.set_index("Pays", inplace=True) # Passage de Pays en index
dispoA = dispoA.drop('Chine') # On enlève la Chine
dispoA =dispoA[(dispoA.Valeur > 0)]
#-----Exporter-----------------------------------------------------------------------------------------------------------
# ListeProduit_V=set(dispoV["Produit"].values.tolist())# 75 produits
# Liste_Produits_Veg = pd.DataFrame(ListeProduit_V)
# Liste_Produits_Veg.to_excel("ListeProduit _ Veg.xlsx", sheet_name="Vegetal", index=True)
# ListeProduit_A=set(dispoA["Produit"].values.tolist())#23 produits
# Liste_Produits_Ani = pd.DataFrame(ListeProduit_A)
# Liste_Produits_Ani.to_excel("ListeProduit _ Ani.xlsx", sheet_name="Animal", index=True)
# Concatener les tables Animal et Végétale
dispo = pd.concat([dispoA, dispoV])
ListeProduit=set(dispo["Produit"].values.tolist()) #98 produits
print(len(ListeProduit))
# Liste_Produits_Ani_Veg = pd.DataFrame(ListeProduit)
# Liste_Produits_Ani_Veg.to_excel("ListeProduit_ Veg et Ani.xlsx", sheet_name="Animal et Vegetal", index=True)
97
# Calculez (pour chaque pays et chaque produit) la disponibilité alimentaire en kcal puis en kg de protéines.
## Calories
Dispo_Alimentaire_Calorie =dispo[dispo['Code Élément'] == '664'] # sous-tableau (Kcal/personne/jour) avec que les kcalorie
# J'ajoute une colonne avec la valeur en année
Dispo_Alimentaire_Calorie['Kcal/personne/an'] = Dispo_Alimentaire_Calorie['Valeur'] * 365
# Mise à jour des titres des colonnes entre les données
Dispo_Alimentaire_Calorie=Dispo_Alimentaire_Calorie.rename(columns={'Valeur':'Kcal/personne/jour'}) # changement du nom
Dispo_Alimentaire_Calorie= Dispo_Alimentaire_Calorie.drop(columns=["Code Élément","Élément","Unité"])
Dispo_Alimentaire_Proteine=dispo[dispo['Code Élément'] == '674']# sous tableau avec que les proteines
# J'ajoute une colonne avec la valeur en année
Dispo_Alimentaire_Proteine ['g/personne/an'] = Dispo_Alimentaire_Proteine['Valeur'] * 365
Dispo_Alimentaire_Proteine ['kg/personne/jour'] = Dispo_Alimentaire_Proteine['Valeur'] * 0.001
Dispo_Alimentaire_Proteine['kg/personne/an'] = Dispo_Alimentaire_Proteine['g/personne/an'] *0.001 # passage en kg
# Mise à jour des titres des colonnes entre les données
Dispo_Alimentaire_Proteine=Dispo_Alimentaire_Proteine.rename(columns={'Valeur':'g/personne/jour'}) # changement du nom
Dispo_Alimentaire_Proteine= Dispo_Alimentaire_Proteine.drop(columns=["Code Élément","Élément","Unité"])
# Fusion des tables Proteine et Population
Dispo_Alimentaire_Proteine = pd.merge(Dispo_Alimentaire_Proteine, PopulationM, on=["Pays"])
Dispo_Alimentaire_Calorie = pd.merge(Dispo_Alimentaire_Calorie, PopulationM, on=["Pays"])
Dispo_Alimentaire_Calorie['kcal/pays/2013'] = Dispo_Alimentaire_Calorie['Kcal/personne/an'] * Dispo_Alimentaire_Calorie['habitant'] # passage population de pays
Dispo_Alimentaire_Proteine ['kg/pays/2013'] =Dispo_Alimentaire_Proteine['kg/personne/an'] * Dispo_Alimentaire_Proteine['habitant'] # passage population de pays
# on notera la presence de 0 dans les produits que le pays ne produit pas
# Calculer par pays, l'ensemble des proteines et des kcal dispo pour les habitants :
Dispo_Alimentaire_Calorie_Sum = Dispo_Alimentaire_Calorie.groupby('Pays').sum('kcal/pays/2013')# group by somme
Dispo_Alimentaire_Calorie_Sum= Dispo_Alimentaire_Calorie_Sum .drop(columns=["habitant"])
Dispo_Alimentaire_Proteine_Sum = Dispo_Alimentaire_Proteine.groupby('Pays').sum('kcal/pays/2013')# Somme
Dispo_Alimentaire_Proteine_Sum = Dispo_Alimentaire_Proteine_Sum.drop(columns=["habitant"])# Somme
#-----Exporter-----------------------------------------------------------------------------------------------------------
# Dispo_Alimentaire_Proteine_Sum= pd.DataFrame(Dispo_Alimentaire_Proteine_Sum)
# Dispo_Alimentaire_Proteine_Sum.to_excel("Somme des proteines en disponibilité par pays.xlsx", sheet_name="Proteine", index=True)
# Dispo_Alimentaire_Calorie_Sum= pd.DataFrame(Dispo_Alimentaire_Calorie_Sum)
# Dispo_Alimentaire_Calorie_Sum.to_excel("Somme des calories en disponibilité par pays.xlsx", sheet_name="Proteine", index=True)
# Calorie - par personne - Top 30
# Graphique lolipops: Graphs premier 30 pays en acces calories par habitants
ordered_kcalPays_Sum = Dispo_Alimentaire_Calorie_Sum.sort_values(by='Kcal/personne/jour')
Premier20 = ordered_kcalPays_Sum.tail(30)
Premier20 = Premier20.rename_axis("Pays").reset_index()
my_range=range(1,len(Premier20.index)+1)
plt.figure(figsize=(14,8)) # taille de la "feuille" (larg, hauteur)
# Graphique horizontal
plt.hlines(y=my_range,
xmin=3200,
xmax=Premier20['Kcal/personne/jour'],
color='darkred')
plt.plot(Premier20['Kcal/personne/jour'], my_range, "o", color='red')
plt.yticks(my_range,Premier20['Pays'])# Add titles and axis names
plt.title(label="Top 30 : Disponibilité journalière en calorie par habitant, en 2013",
loc='left',
fontdict={"fontsize":16},
)
plt.xlabel('kcal / habitant')
plt.ylabel('')
plt.savefig('Top 30 - Disponibilité en calorie par habitant et par jour en 2013.jpg',dpi=500)
# Show the plot
plt.show()
# Graphs Derniers 45 pays en acces calories par habitants
# Proteine - par personne - Top 30
ordered_ProteinePays_Sum= Dispo_Alimentaire_Proteine_Sum.sort_values(by='g/personne/jour')
Premier30 = ordered_ProteinePays_Sum.tail(30)
Premier30 = Premier30.rename_axis("Pays").reset_index()
my_range=range(1,len(Premier30.index)+1)
plt.figure(figsize=(14,8)) # taille de la "feuille" (larg, hauteur)
# The horizontal plot is made using the hline function
plt.hlines(y=my_range,
xmin=100,
xmax=Premier30['g/personne/jour'],
color='darkred')
plt.plot(Premier30['g/personne/jour'], my_range, "o", color='red')
plt.yticks(my_range,Premier30['Pays'],color='black', size=8.5)
plt.title(label="Top 30 : Disponibilité journalière en proteine par habitant, en 2013",
loc='left',
fontdict={"fontsize":16},
)
plt.xlabel('g/ habitant/ jour')
plt.ylabel('')
plt.savefig('Top 30 - Disponibilité en proteine par habitant et par jour en 2013.jpg',dpi=500)
# Show the plot
plt.show()
# Graphs Derniers 45 pays en acces Proteine par habitants
Dernier45 = ordered_ProteinePays_Sum.head(45)
Dernier45 = Dernier45.rename_axis("Pays").reset_index()
my_range=range(1,len(Dernier45.index)+1)
plt.figure(figsize=(18,10)) # taille de la "feuille" (larg, hauteur)
# The horizontal plot is made using the hline function
plt.hlines(y=my_range,
xmin=35,
xmax=Dernier45['g/personne/jour'],
color='yellow')
plt.plot(Dernier45['g/personne/jour'], my_range, "o", color='red')
plt.yticks(my_range,Dernier45['Pays'], color='black', size=6.7)# Add titles and axis names
plt.xticks(fontsize=8)
plt.title(label="Bottom 45 : Disponibilité journalière en proteine par habitant, en 2013",
loc='left',
fontdict={"fontsize":16},
)
plt.xlabel('g/ habitant/ jour',color='black', size=10)
plt.ylabel('')
plt.savefig('Bottom 45 - Disponibilité en proteine par habitant et par jour en 2013.jpg',dpi=500)
# Show the plot
plt.show()
Produit : Nous avions : Dispo_Alimentaire_Calorie & Dispo_Alimentaire_Proteine
Calculer pour la planete, l'ensemble des proteines et des kcal par produit :
Dispo_Alimentaire_CalorieProduit_Sum= Dispo_Alimentaire_Calorie.groupby('Produit').sum('Kcal/personne/jour')# group by somme
Dispo_Alimentaire_CalorieProduit_Sum= Dispo_Alimentaire_CalorieProduit_Sum.drop(columns=["habitant"])
Dispo_Alimentaire_CalorieProduit_Sum= Dispo_Alimentaire_CalorieProduit_Sum.drop(columns=["kcal/pays/2013"])
Dispo_Alimentaire_CalorieProduit_Sum=Dispo_Alimentaire_CalorieProduit_Sum.rename(columns={'Kcal/personne/jour':'Kcal/planete/jour'}) # changement du nom
Dispo_Alimentaire_CalorieProduit_Sum=Dispo_Alimentaire_CalorieProduit_Sum.rename(columns={'Kcal/personne/an':'Kcal/planete/an'}) # changement du nom
Dispo_Alimentaire_ProteineProduit_Sum= Dispo_Alimentaire_Proteine .groupby('Produit').sum('g/personne/jour')
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.drop(columns=["habitant"])
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.drop(columns=["kg/pays/2013"])
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.rename(columns={'g/personne/jour':'g/planete/jour'}) # changement du nom
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.rename(columns={'kg/personne/jour':'kg/planete/jour'})
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.rename(columns={'kg/personne/an':'kg/planete/an'})
Dispo_Alimentaire_ProteineProduit_Sum=Dispo_Alimentaire_ProteineProduit_Sum.rename(columns={'g/personne/an':'g/planete/an'})
#-----Exporter-----------------------------------------------------------------------------------------------------------
Dispo_Alimentaire_ProteineProduit_Sum= pd.DataFrame(Dispo_Alimentaire_ProteineProduit_Sum)
# Dispo_Alimentaire_ProteineProduit_Sum.to_excel("Somme des proteines en disponibilité par produits.xlsx", sheet_name="Proteine", index=True)
Dispo_Alimentaire_CalorieProduit_Sum= pd.DataFrame(Dispo_Alimentaire_CalorieProduit_Sum)
# Dispo_Alimentaire_CalorieProduit_Sum.to_excel("Somme des calories en disponibilité par produit.xlsx", sheet_name="Proteine", index=True)
#Graphs premier 30 produits en calories
ordered_Dispo_Alimentaire_CalorieProduit_Sum = Dispo_Alimentaire_CalorieProduit_Sum.sort_values(by='Kcal/planete/jour')
Premier30 = ordered_Dispo_Alimentaire_CalorieProduit_Sum.tail(30)
Premier30 = Premier30.rename_axis("Produits").reset_index()
my_range=range(1,len(Premier30.index)+1)
plt.figure(figsize=(15,8)) # taille de la "feuille" (larg, hauteur)
plt.hlines(y=my_range,
xmin=0,
xmax=Premier30['Kcal/planete/jour'],
color='darkred')
plt.plot(Premier30['Kcal/planete/jour'], my_range, "o", color='red')
plt.yticks(my_range,Premier30['Produits'])# Add titles and axis names
plt.title(label="Top 30 : Disponibilité journalière mondiale en calorie par produit, en 2013",
loc='left',
fontdict={"fontsize":16},
)
plt.xlabel('kcal/produit',color='black', size=10)
plt.ylabel('')
plt.savefig('Top 30 - Disponibilité journalière mondiale en calorie et par produit en 2013.jpg',dpi=500)
# Show the plot
plt.show()
# Graphs premier 30 produits en proteines :
ordered_Dispo_Alimentaire_ProteineProduit_Sum = Dispo_Alimentaire_ProteineProduit_Sum.sort_values(by='kg/planete/jour')
Premier30 = ordered_Dispo_Alimentaire_ProteineProduit_Sum.tail(30)
Premier30 = Premier30.rename_axis("Produits").reset_index()
my_range=range(1,len(Premier30.index)+1)
plt.figure(figsize=(15,8)) # taille de la "feuille" (larg, hauteur)
plt.hlines(y=my_range,
xmin=0,
xmax=Premier30['kg/planete/jour'],
color='darkred')
plt.plot(Premier30['kg/planete/jour'], my_range, "o", color='red')
plt.yticks(my_range,Premier30['Produits'])# Add titles and axis names
plt.title(label="Top 30 : Disponibilité journalière mondiale en proteine par produit, en 2013",
loc='left',
fontdict={"fontsize":16},
)
plt.xlabel('kg de proteine',color='black', size=10)
plt.ylabel('')
plt.savefig('Top 30 - Disponibilité journalière mondiale en proteine et par produit en 2013.jpg',dpi=500)
# Show the plot
plt.show()
A partir de ces dernières informations, et à partir du poids de la disponibilité alimentaire (pour chaque pays et chaque produit), calculez pour chaque produit le ratio "énergie/poids", que vous donnerez en kcal/kg. Vous pouvez vérifier la cohérence de votre calcul en comparant ce ratio aux données disponibles sur internet, par exemple en cherchant la valeur calorique d'un oeuf.
# Nous avions :
#Dispo_Alimentaire_Calorie ok
Dispo_Alimentaire_Quantite_Produit =dispo[dispo['Code Élément'] == '645']# sous tableau avec que les quantites dispo
# Enlever les colonnes inutiles
Dispo_Alimentaire_Quantite_Produit= Dispo_Alimentaire_Quantite_Produit.drop(columns=["Unité","Code Élément","Élément"])
Dispo_Alimentaire_Quantite_Produit=Dispo_Alimentaire_Quantite_Produit.rename(columns={'Valeur':'kg/personne/an_645Quantite'}) # changement du nom de la colon valeur
Ratio=Dispo_Alimentaire_Calorie.merge(Dispo_Alimentaire_Quantite_Produit, on=['Pays','Produit'])
Ratio=Ratio.drop(columns=["habitant","Code Produit_y", 'kcal/pays/2013', 'Kcal/personne/jour'])
Ratio['Energie_Poids_Kcal/kg'] = Ratio['Kcal/personne/an'] / Ratio['kg/personne/an_645Quantite']
Ratio = Ratio.replace(np.inf,np.nan)
Ratio= Ratio.dropna(how='any')
# Data sur les oeufs :
Ratio_Oeuf=Ratio[Ratio['Produit'] == 'Oeufs'] # sous tableau avec que les oeufs
Ratio_Mean_Oeuf= Ratio_Oeuf.groupby('Produit').mean('Energie_Poids_Kcal/kg')
print(Ratio_Mean_Oeuf['Energie_Poids_Kcal/kg'])
# Oeuf entier : 145 calories pour 100g, soit 1450 pour 1000g (1kg)
Produit Oeufs 1364.156059 Name: Energie_Poids_Kcal/kg, dtype: float64
En considérant les aliments végétaux et animaux, citez 5 aliments parmi les 20 aliments les plus caloriques, en utilisant le ratio énergie/poids.
Ratio_Mean= Ratio .groupby('Produit').mean('Energie_Poids_Kcal/kg')
Ratio_EnergiePoids_Mean= Ratio_Mean.drop(columns=["Kcal/personne/an", "kg/personne/an_645Quantite" ])# Sans les colonnes inutiles
# Graphiques
color =sb.color_palette("Set1",
len(Ratio_Mean ["Energie_Poids_Kcal/kg"]))
z=Ratio_Mean.index
fig=plt.figure(figsize=(10,8))
ax=fig.add_subplot(111)
# Scatter plot (plot à point avec palette de couleur par défaut Viridis()
plt.scatter('Kcal/personne/an', 'kg/personne/an_645Quantite', s=40,c=color, data=Ratio_Mean)
plt.xlabel('Calorie en Kcal', size=14)
plt.ylabel('Quantite en kg')
plt.title(label="Relation entre la quantité et les calories disponible \n par personne et par an, en 2013",
loc='right',
fontdict={"fontsize":16},
)
plt.show()
plt.figure(figsize=(15,8)) # taille de la "feuille" (larg, hauteur)
ordered_Ratio= Ratio_EnergiePoids_Mean.sort_values(by='Energie_Poids_Kcal/kg')# ordination
Premier20 = ordered_Ratio.tail(20) # Top 20.
y_pos = np.arange(len(Premier20))# taille de l axe y
# Graphique :
plt.barh(y_pos,
Premier20['Energie_Poids_Kcal/kg'],
align='center',
alpha=0.8)
plt.xlim([4000, 9000])
plt.yticks(y_pos,Premier20.index)# legende y
plt.xlabel('Kcal/kg')# legence x
plt.title('Les aliments les plus caloriques (Moyenne mondiale)')# titre
plt.savefig('Top 20 - Les aliments les plus caloriques.jpg',dpi=500)
plt.show()
5 Aliments riches : Huile de foie de Poisson, Huile de Sésame, Huile d'olive, Huile d'Arachide, Huile de Maïs
# Table avec les données : Disponibilité alimentaire en quantité (kg/personne/an)
# Dans le même tableau, les proteines et la quantite de produit :
Ratio_Proteine= Dispo_Alimentaire_Proteine.merge(Dispo_Alimentaire_Quantite_Produit, on=['Pays', 'Produit'])
Ratio_Proteine=Ratio_Proteine.drop(columns=["habitant","Code Produit_y", 'kg/pays/2013', 'g/personne/an', 'g/personne/jour','kg/personne/jour'])
# Mise à jour des titres des colonnes entre les données sur les proteines (674) et celles sur les quantités (645)
Ratio_Proteine=Ratio_Proteine.rename(columns={'kg/personne/an':'kg/personne/2013_674'}) # changement du nom 674 = proteine
# Calculs des quantités de proteine par unite de matière de chaque produit en kg puis en gr.
Ratio_Proteine['RatioProteine'] = Ratio_Proteine['kg/personne/2013_674'] / Ratio_Proteine['kg/personne/an_645Quantite']
Ratio_Proteine['Proteine%'] = Ratio_Proteine['RatioProteine']*100
# Retraits des NAN et des inf.
Ratio_Proteine=Ratio_Proteine.replace(np.inf,np.nan)
Ratio_Proteine=Ratio_Proteine.dropna(how='any')
# sous tableau avec les quantités de produits moyen pour chaque produit, en disponibilité mondiale.
Ratio_ProteinePoids_Mean=Ratio_Proteine.groupby('Produit').mean('RatioProteine')
Ratio_ProteinePoids_Mean= Ratio_ProteinePoids_Mean.drop(columns=["kg/personne/2013_674", "kg/personne/an_645Quantite" ])# Sans les colonnes inutiles
# exporter :
#Ratio_ProteinePoids_Mean.to_excel("Ratio_ProteinePoids_Mean.xlsx", sheet_name="Ratio", index=True)
plt.figure(figsize=(15,8)) # taille de la "feuille" (larg, hauteur)
ordered_Ratio=Ratio_ProteinePoids_Mean.sort_values(by='RatioProteine')# ordination
Premier20 = ordered_Ratio.tail(20) # Top 20.
y_pos = np.arange(len(Premier20))# taille de l axe y
# Graphique :
plt.barh(y_pos,
Premier20['RatioProteine'],
align='center',
alpha=0.8)
plt.xlim([0.10, 0.4])
plt.yticks(y_pos,Premier20.index)# legende y
plt.xlabel('Energie_Poids_Kcal/kg')# legence x
plt.title('Les aliments les plus protéiniques (Moyenne mondiale)')# titre
plt.savefig('Top 20 - Les aliments les plus protéiniques.jpg',dpi=500)
plt.show()
Calculez, pour les produits végétaux uniquement, la disponibilité intérieure mondiale exprimée en kcal.
# dispoV pour la disponibilité intérieur :
Dispo_IntV=dispoV[dispoV['Code Élément'] == '5301'] # sous tableau avec que les dispo Veg
# # J'ajoute une colonne avec la valeur en gr
Dispo_IntV['kg/pays/an_5301'] = Dispo_IntV['Valeur'] * 1000000
# Mise à jour des titres des colonnes entre les données
Dispo_IntV=Dispo_IntV.rename(columns={'Valeur':'Milliers_Tonnes_5301'}) # changement du nom
## Nous avons la table Ratio de l'energie avec une colonne en kcal / kg pour chaque produit et chaque pays.
# Dans le même tableau, les kcal et la quantite de produit :
Dispo_IntV_Calorie= Dispo_IntV.merge(Ratio, on=['Pays','Produit'])
# Enlever les colonnes inutiles
Dispo_IntV_Calorie= Dispo_IntV_Calorie.drop(columns=["Unité","Code Produit_x","Milliers_Tonnes_5301", "Élément","Kcal/personne/an","kg/personne/an_645Quantite"])
# Pour vérifier liste des produits :
# ListeProduitDispoMondiale=set(Dispo_IntV_Calorie["Produit"].values.tolist())
# print("Nombre de produits Végétals disponibilité alimentaire : ",len(ListeProduitDispoMondiale)) # 68
# print(ListeProduitDispoMondiale)
# # J'ajoute une colonne avec la valeur en kg
Dispo_IntV_Calorie['DispoCaloriePays_kcal'] =Dispo_IntV_Calorie['kg/pays/an_5301'] * Dispo_IntV_Calorie['Energie_Poids_Kcal/kg']
Total_dispKcal_Veg_Mondial = round((Dispo_IntV_Calorie["DispoCaloriePays_kcal"].sum()),0)
print(f'La disponibilité mondiale en kcal avec que les aliments d origine vegetal en 2013, est de: \n, {int(Total_dispKcal_Veg_Mondial):,} kcal.'.replace(',', ' '))
La disponibilité mondiale en kcal avec que les aliments d origine vegetal en 2013 est de: 11 978 112 189 662 878 kcal.
Combien d'humains pourraient être nourris si toute la disponibilité intérieure mondiale de produits végétaux était utilisée pour de la nourriture ?
Donnez les résultats en termes de calories, puis de protéines, et exprimez ensuite ces 2 résultats en pourcentage de la population mondiale.
# Nous avons déjà :
Nbr_Habitant_Planete2013 =round(int((Total - Chine)*1000),0)
print(f'La population mondiale en 2013 était de {Nbr_Habitant_Planete2013:,},habitants'.replace(',', ' '))
# Pour se nourrir un homme à besoin, chaque jour, de 1 440 à 2 030 kilo-calories, et une femme entre 1 100 et 1 500.
MoyenneBassekcal = round(int(((1440 *365)+(1100*365))/2),0)
MoyenneHautekcal =round(int(((2030*365)+(1500*365))/2),0)
# Calcul du nombre d'humain pouvant être nourris : Calories
MoyenneBasse_Humain_NourrisVegKcal = round(int(Total_dispKcal_Veg_Mondial / MoyenneBassekcal),0)
MoyenneHaute_Humain_NourrisVegKcal = round(int(Total_dispKcal_Veg_Mondial / MoyenneHautekcal),0)
print(f'\nLe nombre d humain pouvant être nourris (en calorie) en 2013 avec la disponibilité intérieure mondiale de produits \n végétaux était de {MoyenneHaute_Humain_NourrisVegKcal:,} à {MoyenneBasse_Humain_NourrisVegKcal:,},habitants'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_Veget_kcal_basse = round(int((MoyenneBasse_Humain_NourrisVegKcal*100)/Nbr_Habitant_Planete2013),0)
PourcentagePopu_Mondiale_Veget_kcal_haute = round(int((MoyenneHaute_Humain_NourrisVegKcal*100)/Nbr_Habitant_Planete2013),0)
print(f' \nSoit entre plus de {PourcentagePopu_Mondiale_Veget_kcal_haute} % et {PourcentagePopu_Mondiale_Veget_kcal_basse}%'.replace(',', ' '))
# ici
# Calcul du nombre d'humain pouvant être nourris : Proteines
## Nous avons la tableQuantite de proteine avec une colonne en cal / gr pour chaque produit et chaque pays
# Mettre dans le même tableau, les proteines et la quantite de produit :
Dispo_IntV_Proteine = Dispo_IntV.merge(Ratio_Proteine, on=['Pays', 'Produit'])
# Enlever les colonnes inutiles
Dispo_IntV_Proteine= Dispo_IntV_Proteine.drop(columns=["Unité","Code Produit_x", "Élément","Milliers_Tonnes_5301","kg/personne/2013_674","kg/personne/an_645Quantite","Proteine%" ])
# J'ajoute une colonne avec la valeur en kg.
Dispo_IntV_Proteine['Dispo_Proteine'] =(Dispo_IntV_Proteine['kg/pays/an_5301'] * Dispo_IntV_Proteine['RatioProteine'])
Total_dispoProteine_Veg_Mondial = round(int(Dispo_IntV_Proteine["Dispo_Proteine"].sum()))
print(f'\nLa disponibilité mondiale en proteine avec que les aliments d origine vegetal en 2013 est de {int(Total_dispoProteine_Veg_Mondial):,} .'.replace(',', ' '))
# On peut également en déduire que les apports recommandés en proteine sont d’environ 50 – 138 g par jour pour une femme,
# et 62 – 170 g pour un homme.
# Attention passer en kg les valeurs en proteine
# Il s’agit cependant de moyennes :
MoyenneBasseProteine = round(int(((0.050*365)+(0.062*365))/2),0)
MoyenneHauteProteine =round(int(((0.138*365)+(0.170*365))/2),0)
# Calcul du nombre d'humain pouvant être nourris.
MoyenneBasse_Humain_NourrisVegProteine = round(int(Total_dispoProteine_Veg_Mondial/MoyenneBasseProteine),0)
MoyenneHaute_Humain_NourrisVegProteine = round(int(Total_dispoProteine_Veg_Mondial/MoyenneHauteProteine),0)
print(f'\nLe nombre d humain pouvant être nourris, en 2013 avec la disponibilité intérieure mondiale de produits végétaux était de {MoyenneHaute_Humain_NourrisVegProteine:,} à {MoyenneBasse_Humain_NourrisVegProteine:,},habitants.'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_Veget_Proteine_basse =round((MoyenneBasse_Humain_NourrisVegProteine*100)/Nbr_Habitant_Planete2013,2)
PourcentagePopu_Mondiale_Veget_Proteine_haute = round((MoyenneHaute_Humain_NourrisVegProteine*100)/Nbr_Habitant_Planete2013,2)
print(f' \nSoit entre plus de {PourcentagePopu_Mondiale_Veget_Proteine_haute} % et {PourcentagePopu_Mondiale_Veget_Proteine_basse}%.'.replace(',', ' '))
La population mondiale en 2013 était de 7 248 628 125 habitants Le nombre d humain pouvant être nourris (en calorie) en 2013 avec la disponibilité intérieure mondiale de produits végétaux était de 18 593 057 068 à 25 839 957 263 habitants Soit entre plus de 256 % et 356% La disponibilité mondiale en proteine avec que les aliments d origine vegetal en 2013 est de 288 588 518 495 . Le nombre d humain pouvant être nourris en 2013 avec la disponibilité intérieure mondiale de produits végétaux était de 5 153 366 401 à 14 429 425 924 habitants. Soit entre plus de 71.09 % et 199.06%.
Combien d'humains pourraient être nourris si toute la disponibilité alimentaire en produits végétaux la nourriture végétale destinée aux animaux et les pertes de produits végétaux étaient utilisés pour de la nourriture ? Donnez les résultats en termes de calories, puis de protéines, et exprimez ensuite ces 2 résultats en pourcentage de la population mondiale.
# Nous avons :
# dispoV pour la disponibilité intérieur :
IndispoPerteAnimaux=dispoV.loc[(dispoV['Code Élément']=='5123')|(dispoV['Code Élément']=='5521')|(dispoV['Code Élément']=='5142')]
IndispoPerteAnimaux=IndispoPerteAnimaux.rename(columns={'Valeur':'Milliers_Tonnes'})#Mise à jour des titres des colonnes entre les données
IndispoPerteAnimaux['kg/pays/an'] = IndispoPerteAnimaux['Milliers_Tonnes'] *1000000# J'ajoute une colonne
# ----Les proteines :
# Dans le même tableau, les proteines et la quantite de produit :
IndispoPerteAnimaux_Sum = IndispoPerteAnimaux.groupby('Produit').sum('kg/pays/an')# group by somme
IndispoPerteAnimaux_Sum=IndispoPerteAnimaux_Sum.rename(columns={'kg/pays/an':'kg/planete/an'})#Mise à jour des titres des colonnes entre les données
IndispoPerteAnimaux_Sum= Ratio_ProteinePoids_Mean.merge(IndispoPerteAnimaux_Sum, on=['Produit'])
#colonne = IndispoPerteAnimaux_Sum.columns # connaitre les titres des colonnes pour les enlever
#print(colonne)
IndispoPerteAnimaux_Sum= IndispoPerteAnimaux_Sum.drop(columns=["Milliers_Tonnes",
"Proteine%"])# Sans les colonnes inutiles
IndispoPerteAnimaux_Sum =IndispoPerteAnimaux_Sum[(IndispoPerteAnimaux_Sum.RatioProteine > 0) ]# Que les valeures positives
# # J'ajoute une colonne avec la valeur en kg
IndispoPerteAnimaux_Sum['indispo_Proteine'] =(IndispoPerteAnimaux_Sum['kg/planete/an'] * IndispoPerteAnimaux_Sum['RatioProteine'])
Total_indispoProteine_Veg_Mondial = round(int(IndispoPerteAnimaux_Sum["indispo_Proteine"].sum()),0)
print(f'\nL indisponibilité mondiale en proteine avec que les aliments d origine vegetale est de: {Total_indispoProteine_Veg_Mondial:,} kg.'.replace(',', ' '))
# Calcul du nombre d'humain pouvant être nourris, si pas de pertes.
MoyenneBasse_Humain_Pouvant_NourrisVegProteine = round(int(Total_indispoProteine_Veg_Mondial /MoyenneBasseProteine),0)
MoyenneHaute_Humain_Pouvant_NourrisVegProteine = round(int(Total_indispoProteine_Veg_Mondial/MoyenneHauteProteine),0)
print(f'Le nombre d humain pouvant être nourris avec l indisponibilité intérieure mondiale de proteine de produits végétaux était de , {MoyenneHaute_Humain_Pouvant_NourrisVegProteine:,} à {MoyenneBasse_Humain_Pouvant_NourrisVegProteine:,},habitants.'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_basse = round((MoyenneBasse_Humain_Pouvant_NourrisVegProteine*100)/Nbr_Habitant_Planete2013,2)
PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_haute = round((MoyenneHaute_Humain_Pouvant_NourrisVegProteine*100)/Nbr_Habitant_Planete2013,2)
print(f'\nSoit entre plus de {PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_haute} % et {PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_basse}% de la population mondiale'.replace(',', ' '))
L indisponibilité mondiale en proteine avec que les aliments d origine vegetale est de: 215 507 557 629 kg. Le nombre d humain pouvant être nourris avec l indisponibilité intérieure mondiale de proteine de produits végétaux était de 3 848 349 243 à 10 775 377 881 habitants. Soit entre plus de 53.09 % et 148.65% de la population mondiale
# ---------- Les calories :
# Dans le même tableau, les calories et la quantite de produit :
IndispoPerteAnimaux_Sum_Calories= Ratio_EnergiePoids_Mean.merge(IndispoPerteAnimaux_Sum, on=['Produit'])
#colonne = IndispoPerteAnimaux_Sum.columns # connaitre les titres des colonnes pour les enlever
#print(colonne)
IndispoPerteAnimaux_Sum_Calories= IndispoPerteAnimaux_Sum_Calories.drop(columns=["indispo_Proteine",
"RatioProteine"])# Sans les colonnes inutiles
IndispoPerteAnimaux_Sum_Calories['indispo_Calorie'] =(IndispoPerteAnimaux_Sum_Calories['kg/planete/an'] *IndispoPerteAnimaux_Sum_Calories['Energie_Poids_Kcal/kg'])
Total_indispoCalorie_Veg_Mondial = round(int(IndispoPerteAnimaux_Sum_Calories["indispo_Calorie"].sum()),0)
print(f'L indisponibilité mondiale en calorie (avec que les aliments d origine vegetal) en 2013, est de: {Total_indispoCalorie_Veg_Mondial:,} Kcal.'.replace(',', ' '))
# Calcul du nombre d'humain pouvant être nourris : Calories, si pas de pertes.
MoyenneBasse_Humain_Pouvant_NourrisVegCalorie = round(int(Total_indispoCalorie_Veg_Mondial/MoyenneBassekcal),0)
MoyenneHaute_Humain_Pouvant_NourrisVegCalorie = round(int(Total_indispoCalorie_Veg_Mondial/MoyenneHautekcal),0)
print(f'\nLe nombre d humain pouvant être nourris en 2013 avec l indisponibilité intérieure mondiale de calorie (de produits végétaux)\nétait de {MoyenneHaute_Humain_Pouvant_NourrisVegCalorie:,} à {MoyenneBasse_Humain_Pouvant_NourrisVegCalorie:,},habitants'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_basse = round((MoyenneBasse_Humain_Pouvant_NourrisVegCalorie*100)/Nbr_Habitant_Planete2013,2)
PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_haute = round((MoyenneHaute_Humain_Pouvant_NourrisVegCalorie*100)/Nbr_Habitant_Planete2013,2)
print(f'\nSoit entre plus de {PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_haute} % et {PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_basse}% de la population mondiale.'.replace(',', ' '))
L indisponibilité mondiale en calorie (avec que les aliments d origine vegetal) en 2013 est de: 8 989 954 119 363 603 Kcal. Le nombre d humain pouvant être nourris en 2013 avec l indisponibilité intérieure mondiale de calorie (de produits végétaux) était de 13 954 680 615 à 19 393 709 673 habitants Soit entre plus de 192.51 % et 267.55% de la population mondiale.
# Autre façon de le faire en incorporant la disponibilité alimentaire en produit végétaux
popu_sans_chine=popu.rename(columns={'Zone':'Pays'})
popu_sans_chine1=popu_sans_chine.set_index("Pays")# set l'index
popu_sans_chine1=popu_sans_chine1.loc[:,"Valeur"]# choisis ma colonne voulus
dispoV1=dispoV.rename(columns={'Zone':'Pays'})
dispoV1=dispoV1.reset_index()
pot_alimentaire_V1=dispoV1[dispoV1.Élément.str.contains('Pertes') ]#millier de tonnes
pot_alimentaire_V2=dispoV1[dispoV1.Élément.str.contains('Disponibilité alimentaire en quantité')]#kg/personne/an
pot_alimentaire_V3=dispoV1[dispoV1.Élément.str.contains('Aliments pour animaux')]#millier de tonne
#Fait 3 datafrae contenant les ligne voulus ( en recherchant les lignes via le str)
pot_alimentaire_V1=pot_alimentaire_V1.loc[:,['Valeur','Produit','Pays']]
pot_alimentaire_V2=pot_alimentaire_V2.loc[:,['Valeur','Produit','Pays']]
pot_alimentaire_V3=pot_alimentaire_V3.loc[:,['Valeur','Produit','Pays']]
#choisis les colonne voulus
pot_alimentaire_V1=pot_alimentaire_V1.rename(columns={'Valeur' : 'Millier de tonne'})
pot_alimentaire_V3=pot_alimentaire_V3.rename(columns={'Valeur' : 'Millier de tonne'})
#rename mes colonne pour savoir quelle sont les unité ( sachant que 2 sont en millier de tonne et l'autre en kg/personne/an)
pot_alimentaire_V2=pd.merge(pot_alimentaire_V2,popu_sans_chine1,on=['Pays'],how='outer')
#merge mon dataframme en kg/personne/ans avec la population pour pouvoir mettre ca en kg/ans puis en tonne
pot_alimentaire_V2['millier de tonne']=((pot_alimentaire_V2['Valeur_x']*pot_alimentaire_V2['Valeur_y'])/1000)
#fait le calcul en faisant (kg/personne/ans) * population puis divise par 1000 pour passer en tonne
pot_alimentaire_V2=pot_alimentaire_V2.loc[:,['Produit','Pays','millier de tonne']]
#elimine mes colonne decevue obsolète
azert=pot_alimentaire_V1['Millier de tonne'].sum()
azert2=pot_alimentaire_V2['millier de tonne'].sum()
azert3=pot_alimentaire_V3['Millier de tonne'].sum()
#fait la somme pour me donner une idée des de la quantité
print(f"mon total en millier de tonne de perte est de :{azert}")
print(f"mon total en millier de tonne d'Aliments pour animaux est de :{azert3}")
print(f"mon total en millier de tonne de Disponibilité alimentaire en quantité est de :{azert2}")
pot_alimentaire_V4=pd.merge(pot_alimentaire_V1,pot_alimentaire_V2,how='outer',on=['Pays','Produit'])
pot_alimentaire_V4=pd.merge(pot_alimentaire_V4,pot_alimentaire_V3,how='outer',on=['Pays','Produit'])
#merge enfin mes 3 dataframmex contenant les pertes,la dispo inter,et la nourriture pour animaux ( pour que toute mes valeur soit sur la meme ligne et facilement "equationnable")
pot_alimentaire_V4=pot_alimentaire_V4.replace(np.nan,0)
#enleve mes nan
pot_alimentaire_V4['total en millier de tonne']=pot_alimentaire_V4['millier de tonne']+pot_alimentaire_V4['Millier de tonne_x']+pot_alimentaire_V4['Millier de tonne_y']
#fait mon calcul qui est une simple addition entre toute mes valeur
azer2=pot_alimentaire_V4['total en millier de tonne'].sum()
print(f'Le total en millier de tonne du potentiel alimentaire et de :{azer2}')
print(f'Le total en kg du potentiel alimentaire et de :{azer2*1000000}')
IndispoPerteAnimaux_Sum1=IndispoPerteAnimaux_Sum.reset_index()
IndispoPerteAnimaux_Sum1=IndispoPerteAnimaux_Sum1.loc[:,['Produit','RatioProteine']]
IndispoPerteAnimaux_Sum1=IndispoPerteAnimaux_Sum1.set_index('Produit')
#isole mon pourcentage de proteine par pays et par produit dans un dataframme
pot_alimentaire_V4=pd.merge(pot_alimentaire_V4,IndispoPerteAnimaux_Sum1,how='outer',on=['Produit'])
#merge mes 2 dataframme pour facilement calculer ma totalité de proteine
pot_alimentaire_V4['prot en millier de tonne']=pot_alimentaire_V4['total en millier de tonne']*pot_alimentaire_V4['RatioProteine']
#calcule ma totailité en tonne de protéine en multipliant ma quantité en tonne par son pourcentage de protéine
azer3=pot_alimentaire_V4['prot en millier de tonne'].sum()
#fait ma somme pour avoir une quantité de protéine total
azer3=azer3*1000000
pot_alimentaire_V4=pd.merge(pot_alimentaire_V4,Ratio_EnergiePoids_Mean,how='outer',on=['Produit'])
#merge ensuite mon dataframme contenant la quantité en tonne avec ma part de kcal/kg
pot_alimentaire_V4['kcal']=pot_alimentaire_V4['total en millier de tonne']*(pot_alimentaire_V4['Energie_Poids_Kcal/kg'])*1000000
#calcule ma totalité de kcal
pot_alimentaire_V4=pot_alimentaire_V4.replace(np.inf,0)
#enleve les potentiel infinis quei sont créer
azer4=pot_alimentaire_V4['kcal'].sum()
#somme pour obtenir mon total de kcal
print(f'L indisponibilité mondiale en calorie (avec que les aliments d origine vegetal) en 2013, est de: {azer4:,} Kcal.'.replace(',', ' '))
# Calcul du nombre d'humain pouvant être nourris : Calories, si pas de pertes.
MoyenneBasse_Humain_Pouvant_NourrisVegCalorie_disp = round(int(azer4/MoyenneBassekcal),0)
MoyenneHaute_Humain_Pouvant_NourrisVegCalorie_disp = round(int(azer4/MoyenneHautekcal),0)
print(f'\nLe nombre d humain pouvant être nourris en 2013 avec l indisponibilité intérieure mondiale de calorie (de produits végétaux)\nétait de {MoyenneHaute_Humain_Pouvant_NourrisVegCalorie_disp:,} à {MoyenneBasse_Humain_Pouvant_NourrisVegCalorie_disp:,},habitants'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_basse_disp = round((MoyenneBasse_Humain_Pouvant_NourrisVegCalorie_disp*100)/Nbr_Habitant_Planete2013,2)
PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_haute_disp = round((MoyenneHaute_Humain_Pouvant_NourrisVegCalorie_disp*100)/Nbr_Habitant_Planete2013,2)
print(f'\nSoit entre plus de {PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_haute_disp} % et {PourcentagePopu_Mondiale_si_dispo_perteVeget_Calorie_basse_disp}% de la population mondiale.'.replace(',', ' '))
print(f'\nL indisponibilité mondiale en proteine avec que les aliments d origine vegetale est de: {azer3:,} kg.'.replace(',', ' '))
# Calcul du nombre d'humain pouvant être nourris, si pas de pertes.
MoyenneBasse_Humain_Pouvant_NourrisVegProteine_disp = round(int(azer3 /MoyenneBasseProteine),0)
MoyenneHaute_Humain_Pouvant_NourrisVegProteine_disp = round(int(azer3/MoyenneHauteProteine),0)
print(f'Le nombre d humain pouvant être nourris avec l indisponibilité intérieure mondiale de proteine de produits végétaux était de , {MoyenneHaute_Humain_Pouvant_NourrisVegProteine_disp:,} à {MoyenneBasse_Humain_Pouvant_NourrisVegProteine_disp:,},habitants.'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_basse_disp = round((MoyenneBasse_Humain_Pouvant_NourrisVegProteine_disp*100)/Nbr_Habitant_Planete2013,2)
PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_haute_disp = round((MoyenneHaute_Humain_Pouvant_NourrisVegProteine_disp*100)/Nbr_Habitant_Planete2013,2)
print(f'\nSoit entre plus de {PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_haute_disp} % et {PourcentagePopu_Mondiale_si_dispo_perteVeget_Proteine_basse_disp}% de la population mondiale'.replace(',', ' '))
mon total en millier de tonne de perte est de :429768.0 mon total en millier de tonne d'Aliments pour animaux est de :1196619.0 mon total en millier de tonne de Disponibilité alimentaire en quantité est de :3668100.40385904 Le total en millier de tonne du potentiel alimentaire et de :5294487.403859039 Le total en kg du potentiel alimentaire et de :5294487403859.039 L indisponibilité mondiale en calorie (avec que les aliments d origine vegetal) en 2013 est de: 9 526 524 766 433 106.0 Kcal. Le nombre d humain pouvant être nourris en 2013 avec l indisponibilité intérieure mondiale de calorie (de produits végétaux) était de 14 787 573 854 à 20 551 234 530 habitants Soit entre plus de 204.01 % et 283.52% de la population mondiale. L indisponibilité mondiale en proteine avec que les aliments d origine vegetale est de: 215 671 037 866.60577 kg. Le nombre d humain pouvant être nourris avec l indisponibilité intérieure mondiale de proteine de produits végétaux était de 3 851 268 533 à 10 783 551 893 habitants. Soit entre plus de 53.13 % et 148.77% de la population mondiale
Combien d'humains pourraient être nourris avec la disponibilité alimentaire mondiale ?
# Nous avons :
# Dispo_Alimentaire_Calorie (pour le monde)
# Dipo_Alimentaire_Proteine (pour le monde)
Total_Dispo_AlimentaireMonde_kCalorie = int(Dispo_Alimentaire_Calorie ["kcal/pays/2013"].sum())
Total_Dispo_AlimentaireMonde_Proteine = int(Dispo_Alimentaire_Proteine ["kg/pays/2013"].sum())
# Donnez les résultats en termes de calories, puis de protéines, et exprimez ensuite ces 2 résultats en pourcentage de la
# population mondiale.
# Calcul du nombre d'humain pouvant être nourris pendant 1 an _ 1 - Proteine
MoyenneBasse_Humain_Nourris_DispoMond_Proteine = round(int(Total_Dispo_AlimentaireMonde_Proteine/ MoyenneBasseProteine),0)
MoyenneHaute_Humain_Nourris_DispoMond_Proteine = round(int(Total_Dispo_AlimentaireMonde_Proteine / MoyenneHauteProteine),0)
print(f'\nLe nombre d humain pouvant être nourris en 2013 avec la disponibilité intérieure mondiale était de {MoyenneBasse_Humain_Nourris_DispoMond_Proteine:,} à {MoyenneHaute_Humain_Nourris_DispoMond_Proteine:,},habitants.'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_dispo_Proteine_basse = round(((MoyenneBasse_Humain_Nourris_DispoMond_Proteine*100)/Nbr_Habitant_Planete2013),2)
PourcentagePopu_Mondiale_dispo_Proteine_haute = round(((MoyenneHaute_Humain_Nourris_DispoMond_Proteine*100)/Nbr_Habitant_Planete2013),2)
print(f'\nSoit entre plus de {PourcentagePopu_Mondiale_dispo_Proteine_haute} % et {PourcentagePopu_Mondiale_dispo_Proteine_basse} % de la population mondiale.'.replace(',', ' '))
Le nombre d humain pouvant être nourris en 2013 avec la disponibilité intérieure mondiale était de 10 283 138 736 à 3 672 549 548 habitants. Soit entre plus de 50.67 % et 141.86 % de la population mondiale.
#### Calcul du nombre d'humain pouvant être nourris pendant 1 an _ 1 - Calorie ----
MoyenneBasse_Humain_Nourris_DispoMond_Calorie = round(int(Total_Dispo_AlimentaireMonde_kCalorie/ MoyenneBassekcal),0)
MoyenneHaute_Humain_Nourris_DispoMond_Calorie = round(int(Total_Dispo_AlimentaireMonde_kCalorie/ MoyenneHautekcal),0)
print(f'\nLe nombre d humain pouvant être nourris en 2013 avec la disponibilité intérieure mondiale en calorie était de {MoyenneBasse_Humain_Nourris_DispoMond_Calorie:,} à {MoyenneHaute_Humain_Nourris_DispoMond_Calorie:,},habitants.'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_dispo_Calorie_basse = round(((MoyenneBasse_Humain_Nourris_DispoMond_Calorie*100)/Nbr_Habitant_Planete2013),2)
PourcentagePopu_Mondiale_dispo_Calorie_haute = round(((MoyenneHaute_Humain_Nourris_DispoMond_Calorie*100)/Nbr_Habitant_Planete2013),2)
print(f'Soit entre plus de {PourcentagePopu_Mondiale_dispo_Calorie_haute} % et {PourcentagePopu_Mondiale_dispo_Calorie_basse}% de la population mondiale.'.replace(',', ' '))
Le nombre d humain pouvant être nourris en 2013 avec la disponibilité intérieure mondiale en calorie était de 15 804 425 901 à 11 372 023 169 habitants. Soit entre plus de 156.89 % et 218.03% de la population mondiale.
Quelle proportion de la population mondiale est considérée comme étant en sous-nutrition ?
dispo_ssAli= pd.read_csv("FAOSTAT_2013_sous_alimentation.csv",
dtype={'Valeur':np.float64},
converters={"Code zone": str,"Code année": str, "Code Élément": str, "Code Produit": str },
decimal='.')
# Le fichier d’insécurité alimentaire inclut 14 variables:
# Le code domaine et sa traduction Domaine : ici, nous sommes dans la sécurité alimentaire,
# Le zone, et sa traduction Zone,
# Le code Element et sa traduction Element, les deux colonnes contiennent des valeurs uniques,
# Le code produit et le produit étudié, les deux colonnes contiennent des valeurs uniques,
# Le code année, qui représente l'interval de 3 années : 2012 - 2014 et sa traduction Année
# Les unités,
# La valeur = le nombre de personnes en sous-alimentation en millions d’habitants,
# Le symbole et sa traduction avec la colonne Description du symbole.
# Sous alimentation :
summary_across_rows = pd.DataFrame(dispo_ssAli).describe()
ListePays_ss_popu=set(dispo_ssAli["Zone"].values.tolist())
print("Nombre de pays dans la table polulation en sous-nutritions: ",len(ListePays_ss_popu)) # Attention il y a 204 pays.
# Nous avons donc les données de sous-nutritions pour 204 sur les 235 pays du monde.
# ATTENTION les valeurs <0.1, sont notees ici 0.1
Nombre de pays dans la table polulation en sous-nutritions: 204
dispo_ssAli.set_index("Zone", inplace=True) # Passage de Pays en index
dispo_ssAli_2013 = dispo_ssAli.drop('Chine') # On enlève la Chine
dispo_ssAli_2013['Pays'] = dispo_ssAli_2013.index
# Simplifier les tables :
dispo_ssAli_2013= dispo_ssAli_2013.drop(columns=["Code Domaine","Domaine", "Produit","Code Produit","Domaine", "Code zone", "Année", "Code année"])
dispo_ssAli_2013=dispo_ssAli_2013.rename(columns={'Valeur':'Million'})#Mise à jour des titres des colonnes entre les données
dispo_ssAli_2013['Personne'] = dispo_ssAli_2013['Million'] *1000000# J'ajoute une colonne Personne
dispo_ssAli_2013= dispo_ssAli_2013.drop(columns=["Unité","Élément","Code Élément"])
dispo_ssAli_2013['Estimation'] =dispo_ssAli_2013['Symbole'].replace('<', '', regex=True)
dispo_ssAli_2013['Estimation'] =dispo_ssAli_2013['Estimation'].str.replace('F', '0')
dispo_ssAli_2013['Estimation'] =dispo_ssAli_2013['Estimation'].str.replace('NV', '0')
dispo_ssAli_2013['Estimation'] = dispo_ssAli_2013['Estimation'].astype('float32')
dispo_ssAli_2013['Estimation-Millions'] = dispo_ssAli_2013['Estimation'] *1000000#
# Calcul sous population :
Total_sousPop_Estimation = int(dispo_ssAli_2013["Estimation-Millions"].sum())
Total_sousPop_Basse = int(dispo_ssAli_2013["Personne"].sum())
NbrPopulation_SousA=Total_sousPop_Basse+Total_sousPop_Estimation
print(f'Le nombre d humain sous alimenté, en 2013 d après la FAO , {Total_sousPop_Basse :,} à {NbrPopulation_SousA:,},habitants'.replace(',', ' '))
# En pourcentage de la population mondiale.
PourcentagePopu_Mondiale_SousA_EstiH = round(((NbrPopulation_SousA*100)/Nbr_Habitant_Planete2013),3)
PourcentagePopu_Mondiale_SousA_EstiB = round(((Total_sousPop_Basse*100)/Nbr_Habitant_Planete2013),3)
print(f' Soit entre plus de {PourcentagePopu_Mondiale_SousA_EstiB} % et {PourcentagePopu_Mondiale_SousA_EstiH}%'.replace(',', ' '))
Le nombre d humain sous alimenté en 2013 d après la FAO 739 700 000 à 782 500 000 habitants Soit entre plus de 10.205 % et 10.795%
RatioA=100-PourcentagePopu_Mondiale_SousA_EstiH
RatioB=(100-PourcentagePopu_Mondiale_SousA_EstiB)-RatioA
RatioC=100-RatioA-RatioB
# create data
plt.figure(figsize=(10,8)) # taille de la "feuille" (larg, hauteur)
size_of_groups=[RatioA,RatioB,RatioC]
# Créer un cercle au centre du graph
my_circle = plt.Circle((0,0), 0.4, color='white')
# explosion
explosion = (0, 0.08, 0.14) # 0 pour l alimentation et 0.008 pour les sous alimentes et les incertains (permets de faire resortir)
# Couleurs
plt.pie(size_of_groups,
labels=['Alimentation suffisante', 'Incertain', 'Sous-alimenté'],
colors=sb.color_palette('Set2'),
autopct='%1.1f%%',
pctdistance=0.65,
explode=explosion,
labeldistance=1.1,
textprops={'fontsize':14}, # taille du texte des étiquettes
startangle=90,
)
p = plt.gcf()
p.gca().add_artist(my_circle)
# Titre
plt.title(label="Pourcentage de la population mondiale \n sous-alimenté en 2013 \n d'après la FAO",
fontdict={"fontsize":16},
pad=20)
plt.savefig('Pourcentage de la population en sous-alimentation.jpg',dpi=500)
# Show the graph
plt.show()
dispo_ssAli2016= pd.read_csv("FAOSTAT_20162019_sous_alimentation.csv",
sep=';',dtype={'Valeur':np.float64},
converters={"Code Pays": str,"Code Année": str, "Code Élément": str, "Code Produit": str },
decimal='.')
popu_1619= pd.read_csv("FAOSTAT_2016-2019_population.csv",
encoding='latin-1',
sep=';',
dtype={'Valeur':np.float64},
converters={"Code Année": str, "Code Élément": str, "Zone": str },
decimal='.')
# Sous alimentation :
ListePays_ss_popu2016=set(dispo_ssAli2016["Zone"].values.tolist())
print("Nombre de pays dans la table polulation en sous-nutritions : ",len(ListePays_ss_popu2016)) # Attention il y a 204 pays.
# Nous avons donc les données de sous-nutritions pour 204 sur les 235 pays du monde. Comme pour 2013.
dispo_ssAli2016.set_index("Zone", inplace=True) # Passage de Pays en index
dispo_ssAli_2016 = dispo_ssAli2016.drop('Chine') # On enlève la Chine
dispo_ssAli_2016['Zone'] = dispo_ssAli_2016.index
# Simplifier les tables :
dispo_ssAli_2016= dispo_ssAli_2016.drop(columns=["Code Domaine","Code zone (M49)", "Domaine", "Produit","Code Produit","Domaine", "Symbole","Description du Symbole", "Code année"])
dispo_ssAli_2016=dispo_ssAli_2016.rename(columns={'Valeur':'Million'})#Mise à jour des titres des colonnes entre les données
dispo_ssAli_2016['Personne'] = dispo_ssAli_2016['Million'] *1000000# J'ajoute une colonne Personne
dispo_ssAli_2016= dispo_ssAli_2016.drop(columns=["Unité","Élément","Code Élément"])
# Calcul sous population :
Total_sousPop_2016 = dispo_ssAli_2016[dispo_ssAli_2016["Année"] =='2015-2017']["Personne"].sum()
Total_sousPop_2019 = dispo_ssAli_2016[dispo_ssAli_2016["Année"] =='2018-2020']["Personne"].sum()
print(f'Le nombre d humain sous alimenté était de : \n en 2016 : {Total_sousPop_2016 :,}\n en 2019 : {Total_sousPop_2019 :,}, d après la FAO '.replace(',', ' '))
Nombre de pays dans la table polulation en sous-nutritions : 204 Le nombre d humain sous alimenté était de : en 2016 : 553 500 000.0 en 2019 : 605 400 000.0 d après la FAO
# Nous avons donc les données de sous-nutritions pour 204 sur les 235 pays du monde. Comme pour 2013.
popu_1619.set_index("Zone", inplace=True) # Passage de Pays en index
popu_1619=popu_1619.drop('Chine') # On enlève la Chine
popu_1619['Zone'] = popu_1619.index
# # En pourcentage de la population mondiale.
popu_1619['Personne'] = popu_1619['Valeur'] *1000# J'ajoute une colonne Personne
Total_Pop_2016=popu_1619[popu_1619["Année"] ==2016]["Personne"].sum()
Total_Pop_2019=popu_1619[popu_1619["Année"] ==2019]["Personne"].sum()
PourcentagePopu_Mondiale_SousA_2016 = round(((Total_sousPop_2016*100)/Total_Pop_2016),3)
PourcentagePopu_Mondiale_SousA_2019 = round(((Total_sousPop_2019*100)/Total_Pop_2019),3)
print(f' Soit en 2016 {PourcentagePopu_Mondiale_SousA_2016} % et en 2019, {PourcentagePopu_Mondiale_SousA_2019}%'.replace(',', ' '))
Soit en 2016 7.369 % et en 2019 7.798%
# create data 2016
RatioA=100-PourcentagePopu_Mondiale_SousA_2016
RatioB=100-RatioA
plt.figure(figsize=(10,8)) # taille de la "feuille" (larg, hauteur)
size_of_groups=[RatioA,RatioB]
# Créer un cercle au centre du graph
my_circle = plt.Circle((0,0), 0.4, color='white')
# explosion
explosion = (0,0.14) # 0 pour l alimentation et 0.008 pour les sous alimentes et les incertains (permets de faire resortir)
# Couleurs
plt.pie(size_of_groups,
labels=['Alimentation suffisante', 'Sous-alimenté'],
colors=sb.color_palette('Set3'),
autopct='%1.1f%%',
pctdistance=0.65,
explode=explosion,
labeldistance=1.1,
textprops={'fontsize':14}, # taille du texte des étiquettes
startangle=90,
)
p = plt.gcf()
p.gca().add_artist(my_circle)
# Titre
plt.title(label="Pourcentage de la population mondiale sous-alimenté en 2016 d'après la FAO",
fontdict={"fontsize":16},
pad=20)
plt.savefig('Pourcentage de la population en sous-alimentation 2016.jpg',dpi=500)
# Show the graph
plt.show()
# create data 2019
RatioA=100-PourcentagePopu_Mondiale_SousA_2019
RatioB=100-RatioA
plt.figure(figsize=(10,8)) # taille de la "feuille" (larg, hauteur)
size_of_groups=[RatioA,RatioB]
# Créer un cercle au centre du graph
my_circle = plt.Circle((0,0), 0.4, color='white')
# explosion
explosion = (0,0.14) # 0 pour l alimentation et 0.008 pour les sous alimentes et les incertains (permets de faire resortir)
# Couleurs
plt.pie(size_of_groups,
labels=['Alimentation suffisante', 'Sous-alimenté'],
colors=sb.color_palette('Set3'),
autopct='%1.1f%%',
pctdistance=0.65,
explode=explosion,
labeldistance=1.1,
textprops={'fontsize':14}, # taille du texte des étiquettes
startangle=90,
)
p = plt.gcf()
p.gca().add_artist(my_circle)
# Titre
plt.title(label="Pourcentage de la population mondiale sous-alimenté en 2019 d'après la FAO",
fontdict={"fontsize":16},
pad=20)
# plt.savefig('Pourcentage de la population en sous-alimentation 2019.jpg',dpi=500)
# Show the graph
plt.show()
#dispoC= dispoC.drop(columns=["Code Domaine","Domaine", "Description du Symbole", "Symbole","Domaine", "Année", "Code Année"])
dispoC.set_index("Pays", inplace=True) # Passage de Pays en index
dispoC = dispoC.drop('Chine') # On enlève la Chine
dispoC =dispoC[(dispoC.Valeur > 0) ]
# Établissez la liste des produits (ainsi que leur code) considéré comme des céréales selon la FAO.
# Nous avons : dispoC
ListeCereales = dispoC.reset_index()
ListeCereales= ListeCereales.drop(columns=["Valeur","Unité","Élément","Code Élément","Pays"])
ListeCereales= ListeCereales[~ListeCereales.duplicated()]# garder qu'une valeur par colonne
En ne prenant en compte que les céréales destinées à l'alimentation (humaine et animale), quelle proportion (en termes de poids) est destinée à l'alimentation animale ?
# Aliments pour Animaux = 5521 et Nourriture = 5142
CerealesAnimaux=dispoC[dispoC['Code Élément'] == '5521'] # sous tableau avec que les Aliments Animaux
Total_CerealesAnimaux = int(CerealesAnimaux["Valeur"].sum())
CerealesHumain=dispoC[dispoC['Code Élément'] == '5142'] # sous tableau avec que la nourriture Humaine
Total_CerealesHumain = int(CerealesHumain["Valeur"].sum())
# calculs Ratio :
CerealeAlimentation=Total_CerealesHumain+Total_CerealesAnimaux
RatioHumainCereales = round(((Total_CerealesHumain*100)/CerealeAlimentation),2)
RatioAnimauxCereales = round(((Total_CerealesAnimaux*100)/CerealeAlimentation),2)
plt.figure(figsize=(10,8)) # taille de la "feuille" (larg, hauteur)
size_of_groups=[RatioHumainCereales,RatioAnimauxCereales]
# Créer un cercle au centre du graph
my_circle = plt.Circle( (0,0), 0.65, color='white') # couleur et taille, et localisation
patches, texts, autotexts =plt.pie(size_of_groups,
labels=['Humaine', 'Animal'],
labeldistance=0.9,
colors=['#ADFF2F', '#FFFF00'],
autopct='%1.2f%%',
pctdistance=0.4, #a distance de l etiquette dans le cercle
textprops={'fontsize':14}, # taille du texte des étiquettes
startangle=90,
)
for text in texts:
text.set_horizontalalignment('center') # Placer les etiquettes legendes au milieu
text.set_verticalalignment('bottom')
for autotext in autotexts: # Placer les etiquettes % au milieu et en italiques
autotext.set_horizontalalignment('center')
autotext.set_verticalalignment('top')
autotext.set_fontstyle('italic')
p = plt.gcf()
p.gca().add_artist(my_circle)
# Titre
plt.title(label="Utilisation des céréales, en 2013, destinée à l'alimentation",
fontdict={"fontsize":16},
pad=20)
plt.savefig('Proportion des céréales destinée à l alimentation.jpg',dpi=500)
# Show the graph
plt.show()
Sélectionnez parmi les données des bilans alimentaires les informations relatives aux pays dans lesquels la FAO recense des personnes en sous-nutrition.
list_pays_sousalim=[]
dispo_ssAli2= pd.read_csv("FAOSTAT_2013_sous_alimentation.csv",
dtype={'Valeur':np.float64},
converters={"Code zone": str,"Code année": str, "Code Élément": str, "Code Produit": str },
decimal='.')
dispo_ssAli1=dispo_ssAli2.rename(columns={'Zone':'Pays'})
dispo_ssAli1
for count1,i in enumerate(dispo_ssAli1.Valeur):
if i!=0:
list_pays_sousalim.append(dispo_ssAli1['Pays'][count1])
dispo_ssAli1=dispo_ssAli1.set_index('Pays')
#fait ue liste prenant tous les pays possédant une part de leur population qui est sous alimenté
dispo_vege_viande_monde=pd.concat([dispoA,dispoV])#créer un dataframme contenant les produit végétaux et animaux
dispo_vege_viande_monde=dispo_vege_viande_monde.reset_index()
dispo_vege_viande_sousalim=dispo_vege_viande_monde.set_index('Pays')
dispo_vege_viande_sousalim=dispo_vege_viande_sousalim.loc[[i for i in list_pays_sousalim if i in dispo_vege_viande_sousalim.index ],:]
#fait un dataframme avec seulement les valeur de l'index(le pays) se trouvant dans ma liste de pays sous-alimenté
dispo_vege_viande_sousalim=dispo_vege_viande_sousalim.reset_index()
#reset l'index
dispo_vege_viande_sousalim_export=dispo_vege_viande_sousalim[dispo_vege_viande_sousalim.Élément.str.contains('Exportation')]
#fait un dataframme avec seulement les lignes sur l'exportation
dispo_vege_viande_sousalim_export=dispo_vege_viande_sousalim_export.loc[:,['Pays','Produit','Valeur']]
#choisis seulement mes colonne voulus
dispo_vege_viande_sousalim_export=dispo_vege_viande_sousalim_export.set_index('Produit')
#met les produit comme index
dispo_vege_viande_sousalim_export=dispo_vege_viande_sousalim_export.drop(labels=['Pays'],axis=1)
#enleve la colonne pays qui n'est plus utile
dispo_vege_viande_sousalim_export_produit=dispo_vege_viande_sousalim_export.groupby(level='Produit').mean()
#fait la moyenne des produit exporter en groupant cela par les produit
dispo_vege_viande_sousalim_export_produit=dispo_vege_viande_sousalim_export_produit.sort_values(by=['Valeur'],ascending=False)
#trie mes resultat du plus grand au plus petit
dispo_vege_viande_sousalim_export_produit_max=dispo_vege_viande_sousalim_export_produit.head(15)
#créer un dataframme contenant seulement mes 15 premiere valeur
names = dispo_vege_viande_sousalim_export_produit_max.index
values = dispo_vege_viande_sousalim_export_produit_max.Valeur
fig, ax = plt.subplots(figsize=(35, 25))
ax.bar(names, values , color='red',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=40)
plt.yticks(fontsize=40)
ax.set_ylabel('millier de tonne',fontsize=40)
plt.title('Produit les plus exporter',fontsize=40)
plt.savefig('Produit les plus exporter.png',bbox_inches='tight')
plt.show()
#fait une figure sur mon dataframme précédant
dispo_vege_viande_sousalim_export_produit_max=dispo_vege_viande_sousalim_export_produit_max.reset_index()
produit_plus_export=list(dispo_vege_viande_sousalim_export_produit_max['Produit'].values.tolist())
#met dans une liste mes produit les plus exporté
dispo_vege_viande_monde_import=dispo_vege_viande_monde[dispo_vege_viande_monde.Élément.str.contains('Importation')]
#créer un dataframme contenant seulement mes importation
dispo_vege_viande_monde_import=dispo_vege_viande_monde_import.loc[:,['Pays','Produit','Valeur']]
#selectionne les colonnes voulus
dispo_vege_viande_monde_import=dispo_vege_viande_monde_import[dispo_vege_viande_monde_import['Produit'].isin(produit_plus_export)]
#prend les lignes contenant seulement les produit contenus dans ma liste des produits les plus exporter
dispo_vege_viande_monde_import=dispo_vege_viande_monde_import.sort_values(by=['Valeur'],ascending=False)
#trie mes valeur du plus grand au plus petit
dispo_vege_viande_monde_import=dispo_vege_viande_monde_import.head(200)
#fait un dataframme avec seulement mes premiere valeur
dispo_vege_viande_monde_import_pays=dispo_vege_viande_monde_import.set_index('Pays')
dispo_vege_viande_monde_import_pays=dispo_vege_viande_monde_import_pays.drop('Produit',axis=1)
#enleve mes produit
dispo_vege_viande_monde_import_pays=dispo_vege_viande_monde_import_pays.groupby(level='Pays').sum()
#groupe mes importation par pays
dispo_vege_viande_monde_import_pays=dispo_vege_viande_monde_import_pays.sort_values('Valeur',ascending=False)
#trie mes pays du plus grand importateur au plus petit
dispo_vege_viande_monde_import_pays=dispo_vege_viande_monde_import.reset_index()
sousalim2=pd.merge(dispo_ssAli1,popu_sans_chine,how='outer',on='Pays')
sousalim2['pourcent sous alim']=(sousalim2['Valeur_x']*1000*100)/sousalim2['Valeur_y']
sousalim2=sousalim2.sort_values('pourcent sous alim',ascending=False)
sousalim2=sousalim2.head(50)
sousalim_max=list(sousalim2.Pays.values.tolist())
replace1 = {"Iran (République islamique d')": "Iran",
"Venezuela (République bolivarienne du)": "Venezuela",
"Chine, Taiwan Province de": "Taiwan"}
dispo_vege_viande_monde_import_pays['Pays'] = dispo_vege_viande_monde_import_pays['Pays'].replace(replace1)
names = dispo_vege_viande_monde_import_pays.Pays
values = dispo_vege_viande_monde_import_pays.Valeur
fig, ax = plt.subplots(figsize=(35, 20))
ax.bar(names, values , color=['blue' if i in sousalim_max else 'red' for i in dispo_vege_viande_monde_import_pays.index],width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=20)
plt.yticks(fontsize=40)
count4=0
patch1 = mpatches.Patch(color='blue', label='Pays top 50 sous-alimentés')
patch2 = mpatches.Patch(color='red', label='Autres pays')
plt.legend(handles=[patch1, patch2],prop={'size': 30})
ax.set_ylabel('milliers de tonnes',size=40)
ax.set_xlabel('Pays',size=40)
plt.title('Pays les plus importateur',size=45)
plt.savefig('Pays les plus importateur.png')
plt.show()
produit_plus_import1=list(dispo_vege_viande_monde_import['Produit'].values.tolist())
#fait une liste contenant mes 200 premier produit les plus importer
produit_plus_import2=list(dispo_vege_viande_monde_import['Pays'].values.tolist())
#fait une liste contenant mes 200 premier pays les plus importateur
dispo_vege_viande_monde_import2=dispo_vege_viande_monde[dispo_vege_viande_monde['Produit'].isin(produit_plus_import1) & dispo_vege_viande_monde['Pays'].isin(produit_plus_import2)]
#refait une dataframme en repartant de mon dataframme contenant tout les disponibilité végetaux et animal mais en ne choississant seulement que les ligne contenant les pays et produit contenant dans mes liste et a la meme pkace dans mes liste
dispo_vege_viande_monde_import2=dispo_vege_viande_monde_import2.loc[:,['Pays','Produit','Élément','Valeur','Code Produit']]
#choisis mes colonne voulus
element=list(set(dispo_vege_viande_monde_import2['Élément'].values.tolist()))
#met les valeur contenus dans la colonne element dans n set pour pouvoir ensuite rename mes colonne valeur par rapport a cette liste
pays=list(dispo_vege_viande_monde_import2['Pays'].values.tolist())
#met tous mes pays dans une liste
produit=list(dispo_vege_viande_monde_import2['Produit'].values.tolist())
#met tous mes produit dans une liste
dispo_vege_viande_monde_import3 = pd.DataFrame(columns=['Pays','Produit','Valeur','Code Produit'])
#créer un dataframme vide
mlkj='Valeur'
mlkj1='Valeur'
for count3,i in enumerate(element):#fait une boucle de merge parcourant mes element(donc mon nombre de merge a faire)
poiu=dispo_vege_viande_monde_import2[dispo_vege_viande_monde_import2.Élément.str.startswith(f"{i}")]
#créer un dataframme contenant ma ligne lié a un element (reset et autre ligne a chaque tour de la boucle)
poiu=poiu.drop(labels=['Élément'],axis=1)
#enleve element qui n'est pas utile
dispo_vege_viande_monde_import3=pd.merge(dispo_vege_viande_monde_import3,poiu,how='outer',on=['Pays','Produit','Code Produit'])
#merge mon dataframe contenant la ligne element[count3] et mon dataframme contenant tout les ligne element precendant (dataframme vide si count3=0)
if mlkj in dispo_vege_viande_monde_import3.columns.tolist():
dispo_vege_viande_monde_import3=dispo_vege_viande_monde_import3.rename(columns={'Valeur': f"{element[int(count3)]}"})
#rename ma colonne Valeur par ce qui est contenus dans element pour eviter de se perdre dans les valeur
if mlkj1 in dispo_vege_viande_monde_import3.columns.tolist():
dispo_vege_viande_monde_import3=dispo_vege_viande_monde_import3.rename(columns={'Valeur': f"{element[int(count3)]}"})
if 'Valeur_x' in dispo_vege_viande_monde_import3.columns.tolist():
dispo_vege_viande_monde_import3=dispo_vege_viande_monde_import3.rename(columns={'Valeur_x': f"{element[int(count3)]}"})
#rename mes colonne Valeur_x et Valeur_y pour eviter de créer des erreur
if 'Valeur_y' in dispo_vege_viande_monde_import3.columns.tolist():
dispo_vege_viande_monde_import3=dispo_vege_viande_monde_import3.rename(columns={'Valeur_y': f"{element[int(count3)]}"})
dispo_vege_viande_monde_import3 = dispo_vege_viande_monde_import3.dropna(axis=1, how='all')
#supprime ma colonne si elle est entierement constitué de nan
dispo_vege_viande_monde_import3=dispo_vege_viande_monde_import3.replace(np.nan,0)
#rempplace mes nan par 0
dispo_vege_viande_monde_import4=dispo_vege_viande_monde_import3.drop(['Pays','Code Produit'],axis=1)
#enleve ma colonne pays qui ne sert plus
dispo_vege_viande_monde_import4=dispo_vege_viande_monde_import4.set_index('Produit')
#choisit mon index etant colonne
dispo_vege_viande_monde_import4=dispo_vege_viande_monde_import4.groupby(level='Produit').sum()
#groupe mes donnée par produit
dispo_vege_viande_monde_import4['ratio (other use)/(dispo inter)']=dispo_vege_viande_monde_import4['Autres Utilisations']/dispo_vege_viande_monde_import4['Disponibilité intérieure']
#calcule mon ration autre ausage par rapport aux disponnibilité interieur
dispo_vege_viande_monde_import4['ratio (nour A)/(nour H+A)']=dispo_vege_viande_monde_import4['Aliments pour animaux']/(dispo_vege_viande_monde_import4['Aliments pour animaux']+dispo_vege_viande_monde_import4['Nourriture'])
#calcule mon ratio de nourriture animal par rapport a ma nourriture total
print(f"le pourcentage(autre utilisation)/(disponibilité intérieur) est en moyenne de : {(dispo_vege_viande_monde_import4['ratio (other use)/(dispo inter)'].mean())*100}%")
print(f"le pourcentage (nourriture A)/(nourriture H+A) est de : {(dispo_vege_viande_monde_import4['ratio (nour A)/(nour H+A)'].mean())*100}%")
dispo_vege_viande_monde_import4_ratio_autre_utilisation=dispo_vege_viande_monde_import4.sort_values(by=['ratio (other use)/(dispo inter)'],ascending=False)
le pourcentage(autre utilisation)/(disponibilité intérieur) est en moyenne de : 8.443652443406052% le pourcentage (nourriture A)/(nourriture H+A) est de : 29.16047082644014%
names = dispo_vege_viande_monde_import4_ratio_autre_utilisation.index
values = dispo_vege_viande_monde_import4_ratio_autre_utilisation['ratio (other use)/(dispo inter)']*100
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(names, values , color='green',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel("%",fontsize=40)
plt.title('Produit le plus haut pourcentage other use/disp_inter',size=45)
plt.savefig('Produit le plus haut ratio other use.png',bbox_inches='tight')
plt.show()
dispo_vege_viande_monde_import4_ratio_nourriture_anim=dispo_vege_viande_monde_import4.sort_values(by=['ratio (nour A)/(nour H+A)'],ascending=False)
names = dispo_vege_viande_monde_import4_ratio_nourriture_anim.index
values = dispo_vege_viande_monde_import4_ratio_nourriture_anim['ratio (nour A)/(nour H+A)']*100
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(names, values , color='green',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel("%",fontsize=40)
plt.title('Produit le plus haut ratio_nour_animal',size=45)
plt.savefig('Produit le plus haut ratio_nour_animal.png',bbox_inches='tight')
plt.show()
Combien de tonnes de céréales pourraient être libérées si les USA diminuaient leur production de produits animaux de 10% ?
USA_AlimAnimaux_Cereales= dispoC[(dispoC['Code Pays']=='231')]
USA_AlimAnimaux_Cereales= USA_AlimAnimaux_Cereales[(USA_AlimAnimaux_Cereales["Élément"]=="Aliments pour animaux")]
Total_USA_AlimAnimaux_Cereale = int(USA_AlimAnimaux_Cereales["Valeur"].sum()) # milliers de tonnes
Total_USA_AlimAnimaux_Cereale10 = (Total_USA_AlimAnimaux_Cereale/10)
print(f"{Total_USA_AlimAnimaux_Cereale10} milliers de tonnes de céréales, qui correspondent à 10 % de la production de céreales des USA, pourraient être libérés.")
14009.6 milliers de tonnes de céréales, qui correspondent à 10 % de la production de céreales des USA, pourraient être libérés.
En Thaïlande, quelle proportion de manioc est exportée ?
Thailande_dispoV=dispoV.query("Pays == 'Thaïlande'")
Thailande_dispoManioc= Thailande_dispoV[(Thailande_dispoV['Produit']=='Manioc')]
Thailande_Production_Manioc = list(Thailande_dispoManioc.query("Élément=='Production'")["Valeur"])[0]
Thailande_Exportation_Manioc = list(Thailande_dispoManioc.query("Élément=='Exportations - Quantité'")["Valeur"])[0]
Ratio_Manioc_Thailande = round(((Thailande_Exportation_Manioc*100)/Thailande_Production_Manioc),2)
print(f'La production de Manioc en Thaïlande en 2013 était de,{int(Thailande_Production_Manioc,):,}, milliers de tonnes.'.replace(',', ' '))
print(f"Cependant le pays exporte {int(Thailande_Exportation_Manioc ,):,}, milliers de tonnes - soit {int(Ratio_Manioc_Thailande,):,}% du Manioc.".replace(',', ' '))
La production de Manioc en Thaïlande en 2013 était de 30 228 milliers de tonnes. Cependant le pays exporte 25 214 milliers de tonnes - soit 83% du Manioc.
fig = plt.figure(figsize =(6.5, 8)) # taille de la "feuille" (larg, hauteur)
Manioc = ['Production', 'Exportation']
x= [Thailande_Production_Manioc,Thailande_Exportation_Manioc]
colors=['cornflowerblue', 'gold']
plt.bar(Manioc, x,
align='center',
width=1.2,
alpha=0.8,
color=colors)
# Show top values
plt.ylabel(' Milliers de tonnes ')# legende
plt.title("Utilisation du Manioc, en Thailande,\n en 2013, d'après la FAO")# titre
plt.savefig('Utilisation du manioc en Thailande 2013.jpg',dpi=500)
# Show the graph
plt.show()
# Quelle est la proportion de personnes en sous-nutrition?
Thailande_Popu_ssAli = list(dispo_ssAli_2013.query("Pays=='Thaïlande'")["Personne"])[0]
print(f'Population sous alimenté en Thaïlande = {int(Thailande_Popu_ssAli,):,}, habitants.'.replace(',', ' '))
Thailande_Popu = PopulationM.query("Pays=='Thaïlande'")["habitant"] #
Thailande_Popu= list(Thailande_Popu)[0]
print(f'Population total en Thaïlande = {int(Thailande_Popu,):,}, habitants.'.replace(',', ' '))
Ratio_SSAli_Thailande = round(((Thailande_Popu_ssAli*100)/Thailande_Popu),2)
print(f'Ratio de la population sous alimente en Thaïlande = {Ratio_SSAli_Thailande:,}%'.replace(',', ' '))
Population sous alimenté en Thaïlande = 6 100 000 habitants. Population total en Thaïlande = 69 578 600 habitants. Ratio de la population sous alimente en Thaïlande = 8.77%
# Graphique Pie
size_of_groups=[(100-Ratio_SSAli_Thailande),Ratio_SSAli_Thailande]
plt.figure(figsize=(10,8)) # taille de la "feuille" (larg, hauteur)
# Couleurs
plt.pie(size_of_groups,
labels=['Alimentation suffisante', 'Sous-alimenté'],
labeldistance=1.1, # distance des étiquettes labels du cercle
colors=['crimson','indigo'],# matplotlib named colors 'tomato', 'cornflowerblue', 'gold', 'orchid', 'green',
autopct='%1.1f%%',# %% pour afficher les %, 1f pour avoir les chiffre à une valeure apres la virgule
pctdistance=0.45, # distance des etiquettes %
textprops={'fontsize':14}, # taille du texte des étiquettes
explode= [0, 0.1],
startangle=0,# Angle pour commencer la "tarte"
)
p = plt.gcf()
# Titre
plt.title(
label='Pourcentage de la population Thaïlandaise en 2013, en sous-nutrition',
fontdict={"fontsize":16},
pad=20)
plt.savefig('Pourcentage de la population Thaïlandaise en sous-alimentation.jpg',dpi=500)
# Show the graph
plt.show()
dispoAnimal = pd.read_csv("FAOSTAT_2013_animal.csv",
dtype={'Valeur':np.float64},
converters={"Code Pays": str,"Code Année": str, "Année": str,"Code Élément": str, "Code Produit": str},
decimal='.')
dispoVegetal= pd.read_csv("FAOSTAT_2013_vegetal.csv",
dtype={'Valeur':np.float64},
converters={"Code Pays": str,
"Code Année": str,
"Année": str,
"Code Élément": str,
"Code Produit": str },
decimal='.')
dispo_vege_viande=pd.concat([dispoAnimal,dispoVegetal])
viande=list(set(dispoAnimal['Produit'].values.tolist()))
vegetal=list(set(dispoAnimal['Produit'].values.tolist()))
dispo_vege_viande['Origine']=['animal' if i in viande else 'vegetal' for i in dispo_vege_viande['Produit']]
dispo_vege_viande=dispo_vege_viande.set_index('Pays')#enleve la chine
dispo_vege_viande=dispo_vege_viande.drop(labels='Chine')
dispo_vege_viande=dispo_vege_viande.reset_index()
dispo_vege_viande2 = pd.DataFrame(columns=['Pays','Produit','Valeur','Code Pays','Code Produit','Année','Origine'])
dispo_vege_viande3=dispo_vege_viande.loc[:,['Pays','Produit','Élément','Valeur','Code Pays','Code Produit','Année','Origine']]
for count3,i in enumerate(element):#fait une boucle de merge parcourant mes element(donc mon nombre de merge a faire)
poiu=dispo_vege_viande3[dispo_vege_viande3.Élément.str.startswith(f"{i}")]
#créer un dataframme contenant ma ligne lié a un element (reset et autre ligne a chaque tour de la boucle)
poiu=poiu.drop(labels=['Élément'],axis=1)
#enleve element qui n'est pas utile
dispo_vege_viande2=pd.merge(dispo_vege_viande2,poiu,how='outer',on=['Pays','Produit','Code Pays','Code Produit','Année','Origine'])
#merge mon dataframe contenant la ligne element[count3] et mon dataframme contenant tout les ligne element precendant (dataframme vide si count3=0)
if mlkj in dispo_vege_viande2.columns.tolist():
dispo_vege_viande2=dispo_vege_viande2.rename(columns={'Valeur': f"{element[int(count3)]}"})
#rename ma colonne Valeur par ce qui est contenus dans element pour eviter de se perdre dans les valeur
if mlkj1 in dispo_vege_viande2.columns.tolist():
dispo_vege_viande2=dispo_vege_viande2.rename(columns={'Valeur': f"{element[int(count3)]}"})
if 'Valeur_x' in dispo_vege_viande2.columns.tolist():
dispo_vege_viande2=dispo_vege_viande2.rename(columns={'Valeur_x': f"{element[int(count3)]}"})
#rename mes colonne Valeur_x et Valeur_y pour eviter de créer des erreur
if 'Valeur_y' in dispo_vege_viande2.columns.tolist():
dispo_vege_viande2=dispo_vege_viande2.rename(columns={'Valeur_y': f"{element[int(count3)]}"})
dispo_vege_viande2 = dispo_vege_viande2.dropna(axis=1, how='all')
#supprime ma colonne si elle est entierement constitué de nan
dispo_vege_viande2=dispo_vege_viande2.replace(np.nan,0)
#rempplace mes nan par 0
dispo_vege_viande_inter=dispo_vege_viande2.set_index('Pays')
dispo_vege_viande_fin=pd.merge(popu_sans_chine1,dispo_vege_viande_inter,how='outer',on=['Pays'])
dispo_vege_viande_fin['dispo_alim_tonnes']=dispo_vege_viande_fin['Disponibilité alimentaire en quantité (kg/personne/an)']*dispo_vege_viande_fin['Valeur']
dispo_vege_viande_fin=dispo_vege_viande_fin.reset_index()
dispo_vege_viande_fin=dispo_vege_viande_fin.replace(np.nan,0)
dispo_vege_viande_fin=dispo_vege_viande_fin.replace(np.nan,0)
dispo_vege_viande_fin = dispo_vege_viande_fin.dropna(subset=['Code Pays', 'Code Produit'])
double=dispo_vege_viande_fin[dispo_vege_viande_fin.duplicated(subset=['Code Pays', 'Code Produit'], keep='first')]
#print(double)
dispo_vege_viande_fin = dispo_vege_viande_fin.loc[~dispo_vege_viande_fin.duplicated(subset=['Code Pays', 'Code Produit'], keep='first')]
dispo_sousalimsql=dispo_ssAli1.reset_index()
code_pays1=dispoVegetal.loc[:,['Pays','Code Pays']]
code_pays1=code_pays1.drop_duplicates()
popusql=popu_sans_chine.loc[:,['Pays','Valeur','Code zone (M49)']]
popusql=popusql.sort_values(by=['Code zone (M49)'])
popusql=pd.merge(popusql,code_pays1,how='outer',on=['Pays'])
popusql=popusql.replace(np.nan,0)
popusql = popusql[popusql['Code zone (M49)'] != 0]
popusql=popusql.dropna()
dispo_sousalimsql=dispo_sousalimsql.dropna()
cnx = mysql.connector.connect(user='root', password='Messor34&1234Messor',
host='localhost',
port='3306',
database='cours',# à enlever si l'on veut créer sa database
charset='utf8')#remplir le password par le sien et remplacer host, user et port part les siens
cursor=cnx.cursor()
#cursor.execute("DROP DATABASE IF EXISTS FAO_stat_2013")
#cursor.execute("CREATE DATABASE FAO_stat_2013")
#cursor.execute('USE FAO_stat_2013')
DB_NAME ='cours'
TABLES= {}
cursor.execute("DROP TABLE if exists `dispo_alim` ")
cursor.execute("DROP TABLE if exists `population` ")
cursor.execute("DROP TABLE if exists `equilibre_prod` ")
cursor.execute("DROP TABLE if exists `sous_nutrition` ")
cursor.execute("DROP TABLE if exists `ratio_sous_alim` ")
TABLES['population']=(
"CREATE TABLE `population` ("
"`Pays` varchar(500),"
"`Code_Pays` int(20),"
"`Pop` float(20),"
"`Code_zone` int(20),"
"PRIMARY KEY (`Code_zone`)"
") ENGINE=InnoDB")
TABLES['dispo_alim'] = (
"CREATE TABLE `dispo_alim` ("
"`Pays` varchar(500) ,"
"`Code_Pays` int(50) ,"
"`Année` int(50) NOT NULL,"
"`Produit` varchar(500) ,"
"`Code_Produit` int(50) ,"
"`Origine` varchar(50) NOT NULL,"
"`dispo_alim_tonnes` float(50),"
"`dispo_alim_kcal_p_j` float(50),"
"`dispo_prot` float(50),"
"`dispo_mat_gr` float(50),"
"PRIMARY KEY (`Code_Pays`,`Code_produit`)"
") ENGINE=InnoDB")
TABLES['equilibre_prod'] = (
"CREATE TABLE `equilibre_prod`("
"`Pays` varchar(500) ,"
"`Code_Pays` int(50) ,"
"`Année` int(50) NOT NULL,"
"`Produit` varchar(500) ,"
"`Code_Produit` int(50) ,"
"`dispo_int` float(50),"
"`alim_ani` float(50),"
"`semences` float(50),"
"`pertes` float(50),"
"`nourriture` float(50),"
"`autres_utilisations` float(50),"
"PRIMARY KEY (`Code_Pays`,`Code_produit`)"
") ENGINE=InnoDB")
TABLES['sous_nutrition']=(
"CREATE TABLE `sous_nutrition` ("
"`Pays` varchar(500),"
"`Code_Pays` int(20),"
"`Sous_pop` float(20),"
"`Année` varchar(500),"
"PRIMARY KEY (`Code_Pays`)"
") ENGINE=InnoDB")
print('create table')
cursor.execute(TABLES['dispo_alim'])
cursor.execute(TABLES['population'])
cursor.execute(TABLES['equilibre_prod'])
cursor.execute(TABLES['sous_nutrition'])
add_equilibre_prod = ("INSERT INTO equilibre_prod "
"(Pays,Code_Pays,Année,Produit,Code_Produit,dispo_int,alim_ani,semences,pertes,nourriture,autres_utilisations)"
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)")
add_popu = ("INSERT INTO population "
"(Pays,Code_Pays,Pop,Code_zone)"
"VALUES (%s, %s, %s, %s)")
add_dispo_alim = ("INSERT INTO dispo_alim "
"(Pays,Code_Pays,Année,Produit,Code_Produit,Origine,dispo_alim_tonnes,dispo_alim_kcal_p_j,dispo_prot,dispo_mat_gr)"
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s )")
add_sous_pop = ("INSERT INTO sous_nutrition "
"(Pays,Code_Pays,Sous_pop,Année)"
"VALUES (%s, %s, %s, %s)")
data_multiple_produit= list(zip(dispo_vege_viande_fin['Pays'],
dispo_vege_viande_fin['Code Pays'],
dispo_vege_viande_fin['Année'],
dispo_vege_viande_fin['Produit'],
dispo_vege_viande_fin['Code Produit'],
dispo_vege_viande_fin['Origine'],
dispo_vege_viande_fin['dispo_alim_tonnes'],
dispo_vege_viande_fin['Disponibilité alimentaire (Kcal/personne/jour)'],
dispo_vege_viande_fin['Disponibilité de protéines en quantité (g/personne/jour)'],
dispo_vege_viande_fin['Disponibilité de matière grasse en quantité (g/personne/jour)']))
data_multiple_sous_pop= list(zip(dispo_sousalimsql['Pays'],
dispo_sousalimsql['Code zone'],
dispo_sousalimsql['Valeur'],
dispo_sousalimsql['Année'],))
data_multiple_equilibre_prod = list(zip( dispo_vege_viande_fin['Pays'],
dispo_vege_viande_fin['Code Pays'],
dispo_vege_viande_fin['Année'],
dispo_vege_viande_fin['Produit'],
dispo_vege_viande_fin['Code Produit'],
dispo_vege_viande_fin['Disponibilité intérieure'],
dispo_vege_viande_fin['Aliments pour animaux'],
dispo_vege_viande_fin['Semences'],
dispo_vege_viande_fin['Pertes'],
dispo_vege_viande_fin['Nourriture'],
dispo_vege_viande_fin['Autres Utilisations']))
data_multiple_popu= list(zip(popusql['Pays'],
popusql['Code Pays'],
popusql['Valeur'],
popusql['Code zone (M49)']))
cursor.executemany(add_dispo_alim,data_multiple_produit)
cursor.executemany(add_popu,data_multiple_popu)
cursor.executemany(add_equilibre_prod,data_multiple_equilibre_prod)
cursor.executemany(add_sous_pop,data_multiple_sous_pop)
def analyse_table_somme_trie(table,valeur,trie,nb,sens='+',calcul=''):
e=[]
sens_trie='ASC' if sens != '+' else 'DESC'
calcul1='AVG' if calcul=='moyenne' else 'SUM'
d=f'''SELECT {calcul1}({table}.{valeur}) AS a2, {table}.{trie}
FROM {table}
GROUP BY {table}.{trie}
ORDER BY a2 {sens_trie}
LIMIT {nb}
'''
cursor.execute(d)
result = cursor.fetchall()
return result
pays_plus_prot=analyse_table_somme_trie('dispo_alim','dispo_prot','Pays',20,'+')
pays_moins_prot=analyse_table_somme_trie('dispo_alim','dispo_prot','Pays',20,'-')
dispo_prot, Pays = zip(*pays_plus_prot)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays,dispo_prot, color='red',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('g/personne/j',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le plus de protéine par habitant',size=45)
plt.show()
dispo_prot1, Pays1 = zip(*pays_moins_prot)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays1,dispo_prot1, color='blue',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('g/personne/j',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le moins de protéine par habitant',size=45)
plt.show()
Utilisation de la fonction pour selectionner nos pays ayant le plus de kcal par habitant
pays_plus_kcal=analyse_table_somme_trie('dispo_alim','dispo_alim_kcal_p_j','Pays',20,'+')
pays_moins_kcal=analyse_table_somme_trie('dispo_alim','dispo_alim_kcal_p_j','Pays',20,'-')
dispo_alim_kcal_p_j, Pays = zip(*pays_plus_kcal)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays,dispo_alim_kcal_p_j, color='red',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('kcal/personne/j',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le plus de calorie par habitant',size=45)
plt.show()
dispo_alim_kcal_p_j1, Pays2 = zip(*pays_moins_kcal)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays2,dispo_alim_kcal_p_j1, color='blue',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('kcal/personne/j',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le moins de calorie par habitant',size=45)
plt.show()
Utilisation de la fonction pour selectionner nos pays ayant le plus perte
pays_plus_perte=analyse_table_somme_trie('equilibre_prod','pertes','Pays',20,'+')
pays_moins_perte=analyse_table_somme_trie('equilibre_prod','pertes','Pays',20,'-')
cursor.execute("SELECT pertes , Pays FROM equilibre_prod")
pertes, Pays3 = zip(*pays_plus_perte)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays3,pertes, color='red',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel("milliers de tonnes",fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le plus de pertes par habitant',size=45)
plt.show()
pertes1, Pays4 = zip(*pays_moins_perte)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays4,pertes1, color='blue',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel("milliers de tonnes",fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le moins de pertes par habitant',size=45)
plt.show()
Création d'une table qui est la OUTER jointure entre la table sous_nutrition et population. Ensuite il y a ajout d'une colonne dans cette ouvelle table qui est le calcul du ratio de population sous-alimentée par pays. Et enfin il y a utilisation de la fonction pour trier les valeur par pays
# Problème avec la connection au serveur mysql, fonctionne sous spyder mais pas sur jupyter. Du coup mise en commentaire
'''
requete_sous_alim= """CREATE TABLE ratio_sous_alim
SELECT pop.Code_pays, pop.Pop, pop.Pays, alim.Sous_pop
FROM sous_nutrition AS alim
LEFT JOIN population AS pop ON (alim.Code_Pays=pop.Code_Pays )
UNION
SELECT pop.Code_pays, pop.Pop, pop.Pays, alim.Sous_pop
FROM population AS pop
LEFT JOIN sous_nutrition AS alim ON (alim.Code_Pays=pop.Code_Pays)
"""
cursor.execute(requete_sous_alim)
requete_sous_alim1='ALTER TABLE ratio_sous_alim ADD pourcent_sous_alim float'
requete_sous_alim2='UPDATE ratio_sous_alim SET pourcent_sous_alim = (Sous_pop*100000)/(Pop)'
cursor.execute(requete_sous_alim1)
cursor.execute(requete_sous_alim2)
pays_plus_sousalim=analyse_table_somme_trie('ratio_sous_alim','pourcent_sous_alim','Pays',20,'+')
pays_moins_sousalim=analyse_table_somme_trie('ratio_sous_alim','pourcent_sous_alim','Pays',20,'-')
pourcent_sous_alim, Pays5 = zip(*pays_plus_sousalim)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays5,pourcent_sous_alim, color='red',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('%',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le plus de pourcentage de sous-alimentés',size=45)
plt.show()
pourcent_sous_alim1, Pays6 = zip(*pays_moins_sousalim)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays6,pourcent_sous_alim1, color='blue',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('%',fontsize=40)
ax.set_xlabel("Pays",fontsize=40)
plt.title('Pays ayant le moins de pourcentage de sous-alimentés',size=45)
plt.show()
'''
'\nrequete_sous_alim= """CREATE TABLE ratio_sous_alim\n SELECT pop.Code_pays, pop.Pop, pop.Pays, alim.Sous_pop\n FROM sous_nutrition AS alim\n LEFT JOIN population AS pop ON (alim.Code_Pays=pop.Code_Pays )\n UNION\n SELECT pop.Code_pays, pop.Pop, pop.Pays, alim.Sous_pop\n FROM population AS pop\n LEFT JOIN sous_nutrition AS alim ON (alim.Code_Pays=pop.Code_Pays)\n """\ncursor.execute(requete_sous_alim)\n\nrequete_sous_alim1=\'ALTER TABLE ratio_sous_alim ADD pourcent_sous_alim float\' \nrequete_sous_alim2=\'UPDATE ratio_sous_alim SET pourcent_sous_alim = (Sous_pop*100000)/(Pop)\'\n\ncursor.execute(requete_sous_alim1)\ncursor.execute(requete_sous_alim2)\n\npays_plus_sousalim=analyse_table_somme_trie(\'ratio_sous_alim\',\'pourcent_sous_alim\',\'Pays\',20,\'+\')\npays_moins_sousalim=analyse_table_somme_trie(\'ratio_sous_alim\',\'pourcent_sous_alim\',\'Pays\',20,\'-\')\n\npourcent_sous_alim, Pays5 = zip(*pays_plus_sousalim)\n\nfig, ax = plt.subplots(figsize=(35, 15))\nax.bar(Pays5,pourcent_sous_alim, color=\'red\',width=0.9)\nplt.xticks(rotation=45, ha=\'right\',fontsize=35)\nplt.yticks(fontsize=35)\nax.set_ylabel(\'%\',fontsize=40)\nax.set_xlabel("Pays",fontsize=40)\nplt.title(\'Pays ayant le plus de pourcentage de sous-alimentés\',size=45)\nplt.show()\n\npourcent_sous_alim1, Pays6 = zip(*pays_moins_sousalim)\n\nfig, ax = plt.subplots(figsize=(35, 15))\nax.bar(Pays6,pourcent_sous_alim1, color=\'blue\',width=0.9)\nplt.xticks(rotation=45, ha=\'right\',fontsize=35)\nplt.yticks(fontsize=35)\nax.set_ylabel(\'%\',fontsize=40)\nax.set_xlabel("Pays",fontsize=40)\nplt.title(\'Pays ayant le moins de pourcentage de sous-alimentés\',size=45)\nplt.show()\n\n'
Création d'une table qui est la OUTER jointure entre la table sous_nutrition et population. Ensuite il y a ajout d'une colonne dans cette ouvelle table qui est le calcul du ratio autre usage par rapport à la disponibilité intérieur. Et enfin il y a utilisation de la fonction pour trier les valeur par pays
# Problème avec la connection au serveur mysql, fonctionne sous spyder mais pas sur jupyter. Du coup mise en commentaire
'''
requete_ratio_autre_usage='ALTER TABLE equilibre_prod ADD pourcent_autre_usage float'
requete_ratio_autre_usage1=''UPDATE equilibre_prod SET pourcent_autre_usage =
CASE WHEN dispo_int != 0 AND autres_utilisations != 0
THEN (autres_utilisations)*100/dispo_int
ELSE 0 END''
cnx.commit()
cursor.execute(requete_ratio_autre_usage)
cnx.commit()
cursor.execute(requete_ratio_autre_usage1)
cnx.commit()
produit_le_plus_autre_usage=analyse_table_somme_trie('equilibre_prod','pourcent_autre_usage','Produit',20,'+','moyenne')
produit_le_moins_autre_usage=analyse_table_somme_trie('equilibre_prod','pourcent_autre_usage','Produit',20,'-','moyenne')
pourcent_autre_usage, Pays7 = zip(*produit_le_plus_autre_usage)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays7,pourcent_autre_usage, color='green',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('%',fontsize=40)
ax.set_xlabel('Produit',fontsize=40)
plt.title("Produit ayant le plus d'autre usage par rapoort a la disponibilité intérieur",size=45)
plt.show()
pourcent_autre_usage1, Pays8 = zip(*produit_le_moins_autre_usage)
fig, ax = plt.subplots(figsize=(35, 15))
ax.bar(Pays8,pourcent_autre_usage1, color='green',width=0.9)
plt.xticks(rotation=45, ha='right',fontsize=35)
plt.yticks(fontsize=35)
ax.set_ylabel('%',fontsize=40)
ax.set_xlabel('Produit',fontsize=40)
plt.title("Produit ayant le moins d'autre usage par rapoort a la disponibilité intérieur",size=45)
plt.show()
cnx.commit()
cursor.close()
cnx.close()
'''
'\nrequete_ratio_autre_usage=\'ALTER TABLE equilibre_prod ADD pourcent_autre_usage float\' \n\nrequete_ratio_autre_usage1=\'\'UPDATE equilibre_prod SET pourcent_autre_usage =\n CASE WHEN dispo_int != 0 AND autres_utilisations != 0 \n THEN (autres_utilisations)*100/dispo_int \n ELSE 0 END\'\'\n\ncnx.commit()\ncursor.execute(requete_ratio_autre_usage)\ncnx.commit()\ncursor.execute(requete_ratio_autre_usage1)\ncnx.commit()\n\nproduit_le_plus_autre_usage=analyse_table_somme_trie(\'equilibre_prod\',\'pourcent_autre_usage\',\'Produit\',20,\'+\',\'moyenne\')\nproduit_le_moins_autre_usage=analyse_table_somme_trie(\'equilibre_prod\',\'pourcent_autre_usage\',\'Produit\',20,\'-\',\'moyenne\')\n\npourcent_autre_usage, Pays7 = zip(*produit_le_plus_autre_usage)\n\nfig, ax = plt.subplots(figsize=(35, 15))\nax.bar(Pays7,pourcent_autre_usage, color=\'green\',width=0.9)\nplt.xticks(rotation=45, ha=\'right\',fontsize=35)\nplt.yticks(fontsize=35)\nax.set_ylabel(\'%\',fontsize=40)\nax.set_xlabel(\'Produit\',fontsize=40)\nplt.title("Produit ayant le plus d\'autre usage par rapoort a la disponibilité intérieur",size=45)\nplt.show()\n\npourcent_autre_usage1, Pays8 = zip(*produit_le_moins_autre_usage)\n\nfig, ax = plt.subplots(figsize=(35, 15))\nax.bar(Pays8,pourcent_autre_usage1, color=\'green\',width=0.9)\nplt.xticks(rotation=45, ha=\'right\',fontsize=35)\nplt.yticks(fontsize=35)\nax.set_ylabel(\'%\',fontsize=40)\nax.set_xlabel(\'Produit\',fontsize=40)\nplt.title("Produit ayant le moins d\'autre usage par rapoort a la disponibilité intérieur",size=45)\nplt.show()\n\n\ncnx.commit()\ncursor.close()\ncnx.close()\n'
Les principaux usages de l'alcool font appel à 5 fonctions attendues : Comme ingrédient de produits et pharmaceutiques, cosmétologiques, Comme solvant, Comme biocide Comme matière première de la chimie, de la pharmacie…, Comme combustible.
Produit 2 : Huile de palme L'huile de palme est principalement utilisée dans l'industrie alimentaire (près de 70 %), dans l'oléochimie (savon, cosmétiques...) et en tant qu'agrocarburant (plus de 20 %)
Les huiles végétales sont très utilisées en cosmétique. L'huile de palmiste est une huile végétale extraite des graines du palmier à huile. Elle est différente de l'huile de palme, extraite de la pulpe du même fruit. L'huile de palmiste a des propriétés émollientes, humectantes et anti-oxydantes, et est utilisée pour fabriquer des savons naturels.
Les graisses animals, comme la graisse de porcs, de vaches et de poulets morts sont utilisée pour fabriquer des carburants plus écologiques. Selon Transport & Environment, un vol Paris-New York nécessiterait la graisse de 8 800 porcs morts si tout le carburant provenait de sources animales. Mais également par les fabricants d'aliments pour animaux de compagnie.
L’huile de colza et l’huile de moutarde ont des utilisations en dehors de l’alimentation. Par exemple, l’huile de colza est utilisée dans la fabrication de produits cosmétiques tels que les savons, les crèmes et les lotions pour le corps1. L’huile de moutarde est utilisée dans la fabrication de bougies, de savons et de parfums2.
Utilisation des plantes aquatique dans le traitement des eaux usées domestiques ou industrielles. La popularité de l’huile de coco vient de ses vertus pour la santé car elle contribue à réduire le taux de « mauvais » cholestérol dans l’organisme. Elle présente une multitude d’usages différents, en cosmétique (soin de la peau, soin capillaire) ou dans l’industrie pharmaceutique.
Les dérivés d'amidon du Manioc ont été utilisés comme épaississants, liants, gonflants et stabilisants, et sont également le meilleur additif, édulcorant, porteur d'arôme et substitut de graisse. Les aliments qui utilisent de l'amidon de manioc thaïlandais comprennent les aliments en conserve, les aliments surgelés, les aliments secs mélangés, les produits de boulangerie, les collations, les condiments, les soupes, les saucisses, les produits laitiers, les produits à base de viande, les produits à base de poisson et les aliments pour bébés.